New to site?


Lost password? (X)

Already have an account?


(X)

Presents

#CSHARPCON20

The C# Corner Annual Conference 2020 is a three-day annual event for software professionals and developers.

3
DAYS
72
SPEAKERS
65
SESSIONS

Magnus Mårtensson
Microsoft Regional Director, Azure MVP, CEO Loftysoft

Avirag Jain
Director & CTO R Systems

Mahesh Chand
Founder C# Corner, CEO Mindcracker

Chris Gali
CEO & Co-Founder Graphite

Subinder Khurana
Chief Architect StoryProcess, Founder NASSCOM DeepTech Club

Bryan Rishforth
Investor, Chairman Graphite

Bryn Everson
Director Biz Dev Graphite

Raj Tiwari
Digital Transformation Leader, Futurist and Visionary

Joseph Guadagno
Microsoft MVP, Lead Quicken Loans

Nikita Sachdev
Entrepreneur, Blockchain Enthusiast & Advisor, Social Media Influencer

Doug Wagner
COO & Founder Adapt Technical Group

Ritesh Modi
Architect, Senior Evangelist, Cloud Architect

Crystal Wenrick
Director Communications Mindcracker

Allen O’Neill
Microsoft MVP, Consulting Engineer/Architect

Praveen Kumar
CEO MCN Solutions

Chris Love
Founder Love2Dev, Microsoft MVP, Author

Sanjay Vyas
Microsoft Regional Director, Microsoft MVP, Founder & CEO SkillLabs Technologies

Veena Sarda
Deep Learning Consultant, Author

Sekhar Srinivasan
C# Corner MVP, Microsoft Certified Trainer, Pluralsight Author

Lalit Bansal
Founder & CEO - EIY SYS

Navdeep Garg
CEO Revinfotech

Prakash Tripathi
Tech Manager/Leader, Microsoft MVP, Blogger

Bhavna Jain
Breakthrough Consultant

Naveen Sharma
Enterprise Architect, Leadership Coach, Author

Vidya Vrat Agarwal
Principal Architect, Microsoft MVP, Author

Sheetal Agarwal
Founder Clownselors, Medical Clown, Trainer

Abhishek Kant
Founder GTM Catalyst

Vishnu Saran
Founder & CEO VoiceQube

Sandeep Soni
Founder & CEO Deccansoft, Microsoft Certified Trainer

Parveen Malik
AVP InfoSec & Vulnerability Management, Information Security Expert

Nitin Pandit
Microsoft MVP, Developer Evangelist, Author

Niloshima Srivastava
C# Corner MVP, Tech Architect, Trainer, Blogger

Bala Chirtsabesan
Senior Software Engineer at Microsoft, Author

Manoj Mittal
Sr. Technical Architect, C# Corner MVP, Author

Chandni Di
Co-Founder Voice of Slum

Vithal Wadje
Technical Lead, Microsoft MVP, Author

Shivam Ahuja
Founder SkillCircle, Business Mentor

Chervine Bhiwoo
Solution Architect, Microsoft MVP, Author

Saurabh Jain
Vice President Paytm, Founder Fun2Do Labs, Author

Vinay Solanki
Head IoT at Lenovo, Founder IoT-NCR

Anshu kumari
Founder Blockchainkids, Inventor, Trainer

Amit Singal
CEO Startup Buddy

Dev Pratap
Co-Founder & CEO Voice of Slum

Amey Vartak
Technology Consultant, Full Stack Developer, C# Corner MVP, Author

Viswanatha Swamy
Principal Software Engineer, C# Corner MVP, Author

Sanket Verma
Research Engineer @ Ballistics (Forensics) and Chair, PyData Delhi

Sourabh Somani
Lead Developer, Microsoft MVP, Author

Abhishek Mishra
Software Architect, C# Corner MVP, Author

Siddharth Vaghasia
Technical Consultant, C# Corner MVP, Blogger

Bassam Alugili
Senior Software Specialist, Database Expert

S Ravi Kumar
Solution Architect, C# Corner MVP, Author

Sundaram Subramanian
Full Stack Developer, C# Corner MVP, Speaker

Deepesh Somani
Solution Architect, Microsoft MVP, Author

Debasis Saha
Technical Project Manager, C# Corner MVP, Blogger, Author

Vipul Jain
Software Architect, C# Corner MVP, Author

Akshay Patel
Technical Architect, Microsoft Certified Trainer, C# Corner MVP, Author

Stephen Simon
RPA Developer, Evangelist, Author

Vivek Sharma
Founder Kingster636, AR/VR Specialist

Jeetendra Gund
Technical Lead, C# Corner MVP, Author

Sujal Beniwal
AI Enthusiast, Student

M Viknaraj
Microsoft MVP, Azure Architect, Author

Prasham Sabadra
Software Architect, C# Corner MVP, Trainer, Author

Aakash Maurya
Senior Developer, C# Corner MVP, Speaker

Ankit Sharma
Senior Software Engineer, C# Corner MVP, Author

Mangesh Gaherwar
Team Lead, C# Corner MVP, Author

Viral Jain
Technical Consultant, C# Corner MVP, Author

Bhasker Das
Solution Architect, Evangelist

Manish Dwivedi
Associate Project Manager

Ck Nitin
Programmer, Author

Rohit Gupta
Technical Trainer, Author

Manish Tewatia
Full-stack Marketer, UX Designer

Bhavya Gaur
Technical Illustrator

Rohit Tomar
SEO/SMO Expert

Web Track

Cloud & Data Track

Dev Track

8am-9am

Registration & Breakfast

9am-10am

Future of Desktop Apps with JS (ElectronJs)

Nitin Pandit

Building Serverless Microservices Using Microsoft Azure

Vithal Wadje

Innovating RPA: A Robot for Every Person

Stephen Simon

10am-11am

Managing Cloud Storage Accounts using Logic Apps

Viknaraj Manogararajah

Data visualization using Python

Sekhar Srinivasan

Going Cross platform with AR Foundation

Vivek Sharma

11am-12pm

Keynote

12pm-1pm

Managing your Azure dependencies in ASP.NET Core apps using VS

Bala Chirtsabesan

Securing Applications on Intelligent Azure

Abhishek Mishra

Getting started with Blazor the Framework of Future

S Ravi Kumar

1pm-2pm

Lunch

2pm-2:45pm

Build Progressive Web Apps using Angular 9

Debasis Saha

Build and deploy to any platform using Azure DevOps

Chervine Bhiwoo

Deep Dive in Azure Service Bus

Akshay Patel

2:45pm-3:45pm

Build a Native Mobile Application using React Native and JavaScript

Joseph Guadagno

Making sense of Web Job, Web Job SDK and Functions in Azure

Prakash Tripathi

CloudFront Distribution in AWS

Viral Jain

3:45pm-4pm

Tea Break

4pm-4:30pm

Introduction to PowerBI

Aakash Maurya

Build Advanced SPFx solutions with React and Graph API

Siddharth Vaghasia

Build Business Intelligence Analyst (BIA) Skills

Sundaram Subramanian

4:30pm-5pm

Deep dive of Power Platform – AI BUILDER

Prasham Sabadra

Panel 1

What's new in SharePoint development

Vipul Jain

5pm-5:30pm

Build a SSO (Single Sign On) based Native JavaScript application with Microsoft Identity within 10 minutes

Manoj Mittal

Panel 2

Applications and working of AI

Veena Sarda

5:30pm-6pm

Deploying serverless API's with .Net core 3.0 on AWS & Azure

Amey Vartak

Panel 3

Blockchain with .NET Core (Ark)

Anshu Kumari

6pm-6:30pm

Closing Note & Prize Distribution

Dev Track

Cloud Track

Architecture Track

Emerging Tech Track

8am-9am

Registration & Breakfast

9am-10am

Creating Full-Stack Web Apps Using Server-Side Blazor

Ankit Sharma

Real time face recognition with MS Cognitive Services

Niloshima Srivastava

Building Scalable APIs with GraphQL

Jeetendra Gund

Future of development with AI and Blockchain

Navdeep Garg

10am-11am

Debugging Tips and Tricks with Visual Studio 2019

Joseph Guadagno

Azure Containers

Abhishek Kant

Enterprise Architecture

Naveen Sharma

Bot Framework - learn it fast and look like a boss!

Allen O’Neill

11am-12:30pm

Keynote

12:30pm-1:30pm

.Net Core & C# 8 Performance

David McCarter

Working with Azure kubernetes services

Ritesh Modi

Becoming an Architect

Vidyavrat Agarwal

Why Techies Need to Learn Product Management

Saurabh Jain

1:30pm-2:30pm

Lunch

2:30pm-3:30pm

Build a rules engine in .Net Core

Sanjay Vyas

Building CI and CD Pipeline using Azure DevOps

Sandeep Soni

Entity Framework Core - Tips and Tricks, Performance Optimization, and Tuning

Bassam Alugili

Hacking your way into Data Science

Sanket Verma

3:30-4:15pm

Speed up your .Net Core Website

Sourabh Somani

Azure

Magnus Mårtensson

Demystifying Open Distro for Elasticsearch

Suman Debnath

Future of Data

Shivam Ahuja

4:15pm-4:30pm

Tea Break

4:30pm-5:15pm

gRPC with C# and .Net Core

Mangesh Gaherwar

Panel 1

Essentials of Cloud security

Parveen Malik

Power platform and Dynamics 365

Deepesh Somani

5:15pm-6pm

Microservices - the gRPC Way

Viswanatha Swamy

Panel 2

Reserved

Reserved

6pm-6:30pm

Closing Note & Prize Distribution

Memory-mapped files for fast inter-process communication in C

A memory-mapped region gives separate C processes a low-latency channel without the repeated payload copies associated with pipes and many socket designs. A producer writes into the mapped region, a consumer reads the same physical pages, and the operating system keeps both views coherent. The technique suits fixed-format telemetry, shared caches and control data exchanged at high frequency on one machine.

The gain is not automatic zero-copy behaviour. The producer still copies its message into the shared region once, but the consumer normally reads those pages directly instead of receiving another kernel-mediated copy. For small, infrequent messages, pipe overhead may be preferable. For frequent structured records on one host, avoiding repeated copies can reduce latency, allocator pressure and system-call work.

Australian estates often mix Windows business applications with Linux services, so a portable protocol is more valuable than a Windows-only shortcut. Sydney financial-services teams and Melbourne logistics operations also have credible high-rate local data paths: order events, telemetry and status updates where another copy through a pipe can consume unnecessary CPU.

At resource operations around Perth, local edge gateways can aggregate sensor readings before sending data to Australian Microsoft Azure and Amazon Web Services regions. A mapping can join processes on that gateway, while a network protocol remains essential between sites. Shared memory is a host-local building block, not a replacement for queues, replication or regional resilience.

Why shared memory changes the cost of IPC

A file-backed mapping participates in the operating system's page cache. Once producer and consumer map the same object, reads and writes target shared physical pages; they do not need fresh socket buffers or a second payload copy. The kernel still handles page faults and cache coherence, so mapping reduces data movement rather than removing all system work.

The approach is strongest when both processes run on one machine, records have a predictable layout, and latency matters more than durability. A regular file provides persistence, while a shared-memory object or pagefile-backed mapping provides temporary storage. Networked workloads still need TCP, queues or RPC, and very small control messages may gain little from mapping.

Mapping a shared file in C

Use one agreed structure for metadata and payload. This POSIX example creates a shared-memory object, establishes its size, then maps it for reading and writing.

#define _POSIX_C_SOURCE 200809L

#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>

typedef struct {
    uint32_t magic;
    uint32_t version;
    uint32_t sequence;
    uint32_t length;
    unsigned char payload[4096];
} SharedRecord;

int main(void)
{
    int fd = shm_open("/c_corner_demo",
                      O_CREAT | O_EXCL | O_RDWR, 0600);

    if (fd == -1) {
        perror("shm_open");
        return 1;
    }

    if (ftruncate(fd, sizeof(SharedRecord)) != 0) {
        perror("ftruncate");
        close(fd);
        return 1;
    }

    SharedRecord *r = mmap(NULL, sizeof *r,
                           PROT_READ | PROT_WRITE,
                           MAP_SHARED, fd, 0);

    if (r == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    r->magic = 0x43535230;
    r->version = 1;
    r->sequence = 0;
    r->length = 0;

    return 0;
}

ftruncate establishes the object's size before any page is touched; otherwise, access beyond the current end can raise SIGBUS. Writes to a MAP_SHARED region become visible to another mapping without a separate write call. msync is for durability rather than routine IPC, and the creator should publish a separate readiness signal before consumers trust the header.

On Linux, the object normally appears under /dev/shm, while POSIX defines the shm_open interface more broadly. Its permissions and lifecycle belong to the application: create it with restricted access, map it in every participant, and call shm_unlink only after all consumers have closed their descriptors.

Coordinating producers and consumers safely

A mapping provides storage, not synchronisation. For a single producer and consumer, two named POSIX semaphores can separate access to free capacity from notification of published records.

sem_t *space = sem_open("/c_corner_space", O_CREAT, 0600, 1);
sem_t *items = sem_open("/c_corner_items", O_CREAT, 0600, 0);

/* Producer */
sem_wait(space);

size_t n = strlen(message);
if (n > sizeof r->payload)
    return 1;

r->sequence++;
r->length = (uint32_t)n;
memcpy(r->payload, message, n);

sem_post(items);

/* Consumer */
sem_wait(items);

printf("%u %.*s\n", r->sequence, (int)r->length, r->payload);

sem_post(space);

The creator initialises space at one and items at zero, then both processes open them by name. sem_wait and sem_post provide the required ordering around the payload copy, preventing a consumer from observing a half-written record. Keep the protected region small, and let the semaphore represent capacity rather than wrapping an expensive operation around the entire record.

A single mapped slot forces producer and consumer to alternate. A ring buffer of records supports a steadier stream, with sequence numbers detecting stale or duplicated entries. Multiple producers usually need a process-shared mutex; multiple consumers need a defined broadcast, queue or broker policy, because a semaphore normally wakes only one waiter.

Comparing local IPC mechanisms

Several mechanisms exchange local data, but their costs and semantics differ:

Mechanism Data movement Coordination Strongest use
Regular file with read and write Copies each operation File locks or external signals Durable files and batch exchange
Pipe or socket pair Copies through a kernel buffer Blocking and readiness are built in Short streams between related processes
Message queue Usually copies each message Bounded queues provide flow control Variable messages and multiple consumers
Memory-mapped region Processes access the same physical pages Requires explicit synchronisation High-rate, host-local structured records

For frequent, bounded records produced by one writer, shared memory offers the fewest payload copies and the simplest high-throughput path. A pipe remains easier when messages are small, stream-oriented or need only kernel-managed blocking. Shared memory earns its complexity when measured latency or CPU usage makes repeated copying material.

Persistence and IPC are different requirements. A file-backed map can provide both, but page-cache pressure and write-back behaviour enter the performance profile. A shared-memory object avoids disk I/O and survives only while the operating system or an explicit unlink operation retains it.

Porting between POSIX and Windows

POSIX uses shm_open, ftruncate and mmap. Windows offers CreateFileMapping or OpenFileMapping, followed by MapViewOfFile; an invalid file handle creates a pagefile-backed object. Named Windows semaphores provide the corresponding wait and signal operations. The algorithm can remain identical while each platform supplies a thin operating-system wrapper.

This is relevant to the C# Corner Annual Conference 2020 audience, where managed services frequently meet native components. A C producer can be called through P/Invoke, or a C# service can use MemoryMappedFile on Windows. A named .NET mapping is not automatically the same object as a POSIX shm_open name, so both sides need one agreed native wrapper or an explicitly shared file and protocol.

Keep the wire layout stable with fixed-width integer fields, documented byte order and explicit structure packing. Compile-time assertions can catch an unexpected record size. The mapping remains host-local: a 64-bit producer and 32-bit consumer can disagree about alignment and atomic operations even when they run on the same Windows or Linux server.

Measuring performance and protecting the mapping

Benchmark the complete exchange rather than mmap alone. Compare throughput and p50 and p99 latency against a pipe or local socket while recording CPU time, context switches and page faults. Use a monotonic clock, warm the pages for steady-state tests, and repeat with realistic record sizes and producer rates.

Cache behaviour can dominate, so measure before applying optimisations. Align active counters to cache lines to avoid false sharing, keep producer and consumer records in predictable slots, and remove unnecessary msync calls. Pre-faulting pages can move first-use cost outside the measured hot path, while excessive preallocation can waste memory on sparse workloads.

Treat shared memory as a trust boundary. Use restrictive POSIX modes and Windows access-control lists, validate magic, version and length fields, and never copy an unchecked length. Sydney financial and healthcare workloads should not leave customer data in shared pages after release, and mapped memory is not a place to store credentials.

Failure handling matters as much as speed. A process can die while holding a semaphore, leaving its peer blocked; timed waits, heartbeats, ownership identifiers and robust process-shared mutexes can expose that state. Stale shared objects and semaphores also need deliberate cleanup, especially in long-running services and development environments.

Applying the pattern to real workloads

A Perth edge gateway can use shared memory between sensor collectors and an analytics worker, while Melbourne warehouse services can exchange high-rate order events locally. In both cases, the mapping handles the host-local fast path, and TCP, MQTT or a managed queue carries data onward to other sites or cloud regions.

A dependable design has one creator, an explicit readiness handshake, a versioned header and a clear owner for each record. A single-writer ring buffer with named semaphores is easy to reason about; broader consumer patterns need an explicit broker. Tests should cover process termination, stale versions, malformed lengths and restart behaviour.

Memory-mapped files then become a measured transport choice rather than a fashionable trick. Shared pages, narrow ownership and disciplined synchronisation can deliver the required throughput while keeping the limits of host-local IPC visible.

The Leela Ambience Convention Hotel

1, CBD, Maharaj Surajmal Road, Near Yamuna Sports Complex, Delhi, 110032

KNOW MORE

GENERAL QUERIES


Manish Tewatia

+91-9718-431-042

TICKET QUERIES


Atul Gupta

+91-9910-125-804