c# shared momory #2

-
메모리 맵을 위해 파일뷰를 생성하는 클래스 입니다.

MemoryMappedFile.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
using System;
using System.Runtime.InteropServices;
 
namespace SMC_Mapper
{
    class MemoryMappedFile : IDisposable
    {
        private IntPtr fileMapping;
        private readonly int size;
        private readonly FileAccess access;
 
        public enum FileAccess : int
        {
            ReadOnly = 2,
            ReadWrite = 4
        }
 
        private MemoryMappedFile(IntPtr fileMapping, int size, FileAccess access)
        {
            this.fileMapping = fileMapping;
            this.size = size;
            this.access = access;
        }
 
        public static MemoryMappedFile CreateFile(string name, FileAccess access, int size)
        {
            if (size < 0)
                throw new ArgumentException("Size must not be negative", "size");
 
            IntPtr fileMapping = sharedMemoryController.CreateFileMapping(0xFFFFFFFFu, null, (uint)access, 0, (uint)size, name);
            if (fileMapping == IntPtr.Zero)
                throw new MemoryMappingFailedException();
 
            return new MemoryMappedFile(fileMapping, size, access);
        }
 
        public MemoryMappedFileView CreateView(int offset, int size, MemoryMappedFileView.ViewAccess access)
        {
            if (this.access == FileAccess.ReadOnly && access == MemoryMappedFileView.ViewAccess.ReadWrite)
                throw new ArgumentException("Only read access to views allowed on files without write access", "access");
            if (offset < 0)
                throw new ArgumentException("Offset must not be negative", "size");
            if (size < 0)
                throw new ArgumentException("Size must not be negative", "size");
            IntPtr mappedView = sharedMemoryController.MapViewOfFile(fileMapping, (uint)access, 0, (uint)offset, (uint)size);
            return new MemoryMappedFileView(mappedView, size, access);
        }
 
        #region IDisposable Member
 
        public void Dispose()
        {
            if (fileMapping != IntPtr.Zero)
            {
                if (sharedMemoryController.CloseHandle((uint)fileMapping))
                    fileMapping = IntPtr.Zero;
            }
        }
 
        #endregion
    }
}
 

아래는 실제로 읽고 쓰는 함수들이 저장되어있습니다.

MemoryMappedFileView.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
using System;
using System.Runtime.InteropServices;
 
namespace SMC_Mapper
{
    class MemoryMappedFileView : IDisposable
    {
        private IntPtr mappedView;
        private readonly int size;
        private readonly ViewAccess access;
 
        public enum ViewAccess : int
        {
            ReadWrite = 2,
            Read = 4,
        }
 
        internal MemoryMappedFileView(IntPtr mappedView, int size, ViewAccess access)
        {
            this.mappedView = mappedView;
            this.size = size;
            this.access = access;
        }
 
        public int Size
        {
            get { return size; }
        }
 
        public void ReadBytes(byte[] data)
        {
            ReadBytes(data, 0);
        }
        public void ReadBytes(byte[] data, int offset)
        {
            for (int i = 0; i < data.Length; i++)
                data[i] = Marshal.ReadByte(mappedView, offset + i);
        }
 
        public void WriteBytes(byte[] data)
        {
            WriteBytes(data, 0);
        }
        public void WriteBytes(byte[] data, int offset)
        {
            for (int i = 0; i < data.Length; i++)
                Marshal.WriteByte(mappedView, offset + i, data[i]);
        }
 
        #region Additional Accessors
        public byte ReadByte(int offset)
        {
            return Marshal.ReadByte(mappedView, offset);
        }
        public void WriteByte(byte data, int offset)
        {
            Marshal.WriteByte(mappedView, offset, data);
        }
 
        public short ReadInt16(int offset)
        {
            return Marshal.ReadInt16(mappedView, offset);
        }
        public void WriteInt16(short data, int offset)
        {
            Marshal.WriteInt16(mappedView, offset, data);
        }
 
        public int ReadInt32(int offset)
        {
            return Marshal.ReadInt32(mappedView, offset);
        }
        public void WriteInt32(int data, int offset)
        {
            Marshal.WriteInt32(mappedView, offset, data);
        }
 
        public long ReadInt64(int offset)
        {
            return Marshal.ReadInt64(mappedView, offset);
        }
        public void WriteInt64(long data, int offset)
        {
            Marshal.WriteInt64(mappedView, offset, data);
        }
 
        public object ReadStructure(Type structureType)
        {
            return Marshal.PtrToStructure(mappedView, structureType);
        }
        public void WriteStructure(object data)
        {
            Marshal.StructureToPtr(data, mappedView, true);
        }
 
        public object ReadDeserialize()
        {
            return ReadDeserialize(0, size);
        }
        public object ReadDeserialize(int offset)
        {
            return ReadDeserialize(offset, size - offset);
        }
        public object ReadDeserialize(int offset, int length)
        {
            byte[] binaryData = new byte[length];
            ReadBytes(binaryData, offset);
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter
                = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            System.IO.MemoryStream ms = new System.IO.MemoryStream(binaryData, 0, length, true, true);
            object data = formatter.Deserialize(ms);
            ms.Close();
            return data;
        }
 
        /// <summary>
        /// Serializes the data and writes it to the file.
        /// </summary>
        /// <param name="data">The data to serialize.</param>
        public void WriteSerialize(object data)
        {
            WriteSerialize(data, 0, size);
        }
        /// <summary>
        /// Serializes the data and writes it to the file.
        /// </summary>
        /// <param name="data">The data to serialize.</param>
        /// <param name="offset">The position in the file to start.</param>
        public void WriteSerialize(object data, int offset)
        {
            WriteSerialize(data, 0, size - offset);
        }
        /// <summary>
        /// Serializes the data and writes it to the file.
        /// </summary>
        /// <param name="data">The data to serialize.</param>
        /// <param name="offset">The position in the file to start.</param>
        /// <param name="length">The buffer size in bytes.</param>
        public void WriteSerialize(object data, int offset, int length)
        {
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter
                = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            byte[] binaryData = new byte[length];
            System.IO.MemoryStream ms = new System.IO.MemoryStream(binaryData, 0, length, true, true);
            formatter.Serialize(ms, data);
            ms.Flush();
            ms.Close();
            WriteBytes(binaryData, offset);
        }
        #endregion
 
        #region IDisposable Member
 
        public void Dispose()
        {
            if (mappedView != IntPtr.Zero)
            {
                if (sharedMemoryController.UnmapViewOfFile(mappedView))
                    mappedView = IntPtr.Zero;
            }
        }
 
        #endregion
    }
}
 


아래는 예외처리 클래스인데.. 특별하게 구현하지는 않았네요..

MemoryMappingFailedException.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
 
 
namespace SMC_Mapper
{
    [Serializable]
    class MemoryMappingFailedException : Exception
    {        
        public MemoryMappingFailedException() : base()
        {
        }
    }
}
 


위의 클래스들로 DLL을 하나 만들고 참조해서 사용합니다.

Mapper m_Mapper = new Mapper();
m_Mapper.m_MapDic[메모리맵이름].Write(....);
m_Mapper.m_MapDic[메모리맵이름].Read(....);

하면 간단하게 읽고 쓰기가 가능합니다.

저같이 여러개를 여는것이 아니라면 Mapper라는 클래스가 따로 필요는 없고

file = MemoryMappedFile.CreateFile(mapName, MemoryMappedFile.FileAccess.ReadWrite, size);
view = file.CreateView(0, size, MemoryMappedFileView.ViewAccess.ReadWrite);
 
요 부분만 가지고 있으면 되겠지요..

댓글

댓글 쓰기

이 블로그의 인기 게시물

c# GDI+ 꺼져!! BufferedGraphics

-
요즘세상에서 c#의 gdi가 c++의 gdi 보다 느리다라고 하는 사람들이 있습니다... 뭐 느릴수도 있겠죠... 근데 너무 우기는건 좀 아닌거 아닌가욤(먼소리지) 저는 mfc도 개발하고 c#도 개발하고.. 사실 더 그래픽컬하고 gdi를 많이 쓰는건 c# 개발할때 였습니다... 처음에 c#으로 개발할때 paint 는 정말 못쓸정도였(!?)지만 방법이 없는건 아니었죠.. 결국 사람들이 방법을 모르는거지 누가빠르고 누가 느리다라고 승질낼일은 아닌거 같네요.. 글 옮기다가 갑자기 생각나서 몇자 추가해봅니다.. C# 에서 더블 버퍼링은 정말 간단하게 설정이 됩니다. 그것이 폼이든 판넬이든 말이죠. this.SetStyle(ControlStyles.DoubleBuffer, true); this.SetStyle(ControlStyles.UserPaint, true); this.SetStyle(ControlStyles.AllPaintingInWmPaint, true); 요 3줄이면 설정이 끝나죠( 저같은 경우는 form이나 panel, pictureBox를 상속받는 더블버퍼용 컨트롤을 새로 만들어서 사용합니다.) 그러나! 더블버퍼링을 위한( 꼭 위한은 아닙니다. 더블버퍼링을 사용하지 않더라도 ) GDI+ 의 성능 개선을 위한 graphics 객체가 있었으니 그 이름하여 BufferedGraphics !!! 보통 Paint 함수에서 Graphics g = e.Graphics ; 이런식으로 Graphic 객체를 생성하여서 사용하는데요... BufferedGraphics는 약간 다릅니다. Paint 부분 소스입니다.  private void Paint(object sender, PaintEventArgs e)         {             if (...
자세한 내용 보기

c# 에서 C++ dll 사용하기

-
이미지
C#에서 C++로 제작된 DLL을 사용하기 위한방법은 제가 아는건 크게 2가지 입니다. 1. DllImport 를 사용하는 방법 아마 대부분의 dll을 호출하는 방법이 DllImport 일것입니다... 이부분은 워낙 자료가 많으니 패쓰 2. Wrapper를 이용하여 Wrapping하는 방법 CLR을 이용하여 래핑하는 방법입니다. 물론 C++을 할줄 알아야 하는거구요.. 저는 단순히 기본적인 래핑법만 소개하겠습니다. 우선 비쥬얼 스튜디오를 실행합니다. 프로젝트를 VC++의 CLR을 선택합니다. VS2010 프리미엄 정품!! 입니다. ㅋㅋ 위와 같이 프로젝트를 만들어 줍니다.. 그리고 프로젝트에 래핑항 라이브러리를 import 해주시고.. 전 VS2010의 이 화면이 너무 마음에 들어용ㅇㅇㅇㅇ (예전에 쓴글이라 그래요.. 지금은 2012사용중.. ㅎㅎ) 머 대충 기본생성된 모습입니다. 왠지모르게 c#의 냄새가.. 필요한 dll을 wrapping하기 위해 새로운 클래스를 만들겠습니다. 이렇게 해서 wrapping은 끝납니다. 정말 간단하죠? 컴파일하고 만들어진 dll을 c# 프로젝트에서 참조추가 해주시면 됩니다. 문제는 위의 코드에서는 그냥 단순히 int 형을 넘기고 int 를 리턴받는 형식입니다만 c++이나 mfc로 dll을 만들다 보면 c++ 내에서만 쓰이는 변수형을 사용하게 됩니다. 그중 포인터와 구조체 이런거 뺴고 변수만 따졌을때 가장 많은 질문을 하는것이 c#의 string과 mfc의 CString간의 전달방법인데요. 생각보다 아주 간단합니다.  c# 쪽에서는 그냥 string으로 함수로 넘겨주고 wrapping 해주는 쪽에서 받을때 System::String^ 으로 받아서 CString 쪽으로 그냥 전달해주시면 됩니다. 이 간단한걸 얼마나 찾았던지 ㄷㄷㄷㄷㄷㄷㄷ 아래와 같은 형식이군요 int cppLibWrap::DLL_ReadISCE(System::String^ i...
자세한 내용 보기

c# string 에서 mfc의 LPCTSTR간의 변환

-
이미지
mfc 로 만들 DLL 함수중 문자열을 인자로 받는 함수가 있었습니다. 처음 dll을 만들때는 CString으로 만들었었죠. 결과적으로 c# 에서 string을 바로 CString으로 변환하는 방법은 래핑하는 방법밖에 없었구요(잘 찾아보면 있을지도..) 그래서 CString 으로 선언된 인자를 LPCTSTR로 변경하였습니다. extern "C" __declspec(dllexport) int DLL_SetFile(LPCSTR filePath) { CString path(filePath); . . . . } 이런식으로 만들어서 인자값을 간단하게 CString으로 변화하여 MFC에서는 사용을 합니다. 자 그럼 c#에서 이 함수를 어떻게 사용하느냐.. 일단 string값을 바로 대입할 수 는 없습니다. 변환을 한번 해줘야 하는데 바로 IntPtr값으로 변환을 한번 해주어야 합니다. IntPtr 형식은 그 크기가 플랫폼마다 고유한 정수로 디자인되었습니다. 즉, 이 형식의 인스턴스는 32비트 하드웨어 및 운영 체제에서는 32비트로, 64비트 하드웨어 및 운영 체제에서는 64비트여야 합니다. IntPtr 형식은 포인터를 지원하는 언어에서 사용할 수 있으며, 포인터를 지원하는 언어와 포인터를 지원하지 않는 언어 사이에서 데이터를 참조하는 일반적인 방법이 됩니다. 핸들을 보관하는 데도 IntPtr 개체를 사용할 수 있습니다. 예를 들어, IntPtr 의 인스턴스는 파일 핸들을 보관하기 위해 System.IO . . :: .  FileStream 클래스에서 광범위하게 사용됩니다. IntPtr 형식은 CLS 규격이지만, UIntPtr 형식은 그렇지 않습니다. 공용 언어 런타임에서는 IntPtr 형식만 사용됩니다. UIntPtr 형식은 IntPtr 형식과의 구조적 대칭을 유지하기 위해 주로 사용됩니다. 이 형식은 ISerializable 인터페이스를 구현합니다 간단한 함수를 하나 만들...
자세한 내용 보기