1:
2:
3:
4:
5:

class Auto
{
   public string Farbe { get; set; }
   public string Marke { get; set; }
}					

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:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:

        public static object ConvertToDynType(Dictionary<string, object> ClassDefinition, string name, bool ConvertSubs)
        {
            // This code creates a single-module assembly (.dll). The module contains 
            // a type (consisting of objects), which is defined by Classdefinition. The key
            // is object-name, the dict-value is allocated to the objects value.
            // The resulting Type is "VDynamicType", that have the (public) fields and
            // the appropriate properties that gets and sets the fields and a constructors that 
            // initialize the fields.

            Dictionary<string, object> ClassDef_tmp =
                new Dictionary<string, object>(ClassDefinition);

            AssemblyName aName = new AssemblyName(name);

            // Writes a new Assembly in actual App-Domain
            AssemblyBuilder ab =
                AppDomain.CurrentDomain.DefineDynamicAssembly(
                    aName,
                    AssemblyBuilderAccess.RunAndSave);

            // Calls the ModuleBuilder to Create a new Module in the Assembly

            ModuleBuilder mb =
                ab.DefineDynamicModule(aName.Name, "VDynLib" + ".dll");
            
            // TypeBuilder to Create a new (public) class
            // is like:
            // public class VoithDynamicType
            // {
            // }
            TypeBuilder tb = mb.DefineType(
                name,
                 TypeAttributes.Public);




            // Creates a FieldBuilder-Array to create new objects
            // The Array-Size is the number of keys in ClassDef_tmp
            // (we want the same amount of object in the new Class).
            FieldBuilder[] Fields = new FieldBuilder[ClassDef_tmp.Keys.Count];

            // Creates a Type-Array. That´s necessary for the Konstruktor and
            // and to set the types of the object (we could take 'object' as
            // global type, but thats would be a little bit slower and takes
            // more Cache in the stack
            Type[] parameterTypes = new Type[Fields.Count()];


            // if the ClassDef_tmp contains sub-dictionaries, the are also converted
            // to a dynamic type
            if (ConvertSubs)
                for (int j = 0; j < ClassDef_tmp.Count; j++)
                {
                    if (ClassDef_tmp.Values.ToArray()[j] != null && ClassDef_tmp.Values.ToArray()[j].GetType() == typeof(Dictionary<string, object>))
                    {
                        string sub_name = "Type" + ClassDef_tmp.Keys.ToArray()[j];
                        object subType = ConvertToDynType((Dictionary<string, object>)ClassDef_tmp.Values.ToArray()[j], sub_name);
                        ClassDef_tmp[ClassDef_tmp.Keys.ToArray()[j]] = subType;
                    }
                }

            // Add the private fields
            for (int i = 0; i < ClassDef_tmp.Count; i++)
            {   Type T1 = typeof(object);
                //Get the Type of the value
               if(ClassDef_tmp.Values.ToArray()[i] == null)
                 T1 = typeof(object);
               else
                T1 = ClassDef_tmp.Values.ToArray()[i].GetType();


                //If the type of the value is a dynamic type, then save it
                //as 'object', else take the type of the value
                Type RefType = T1.FullName == tb.FullName ?
                    typeof(object) : T1;

                //Defines the Field
                //Like:
                // private string name;
                // private int TestInt;
                // ...
                Fields[i] = tb.DefineField(
                   "_" + ClassDef_tmp.Keys.ToArray()[i],
                   RefType,
                   FieldAttributes.Private);

                //fills the Type-Arr for the constructor-def
                if (ClassDef_tmp.Values.ToArray()[i] == null)
                    parameterTypes[i] = typeof(object);
                else
                    parameterTypes[i] = ClassDef_tmp.Values.ToArray()[i].GetType();

            }

            // Define a constructor that takes the object arguments and 
            // stores it in the fields. 
            // Like:
            // public VoithDynamicClass(int i1, string s1, double d1, int i2, ...)

            ConstructorBuilder ctor1 = tb.DefineConstructor(
                MethodAttributes.Public,
                CallingConventions.Standard,
                parameterTypes);

            // Creates an MSIL-Generator
            // (The Language between Assembler and Compiler)
            ILGenerator ctor1IL = ctor1.GetILGenerator();


            // Push the Instance of our new Class to the stack
            ctor1IL.Emit(OpCodes.Ldarg_0);

            // Creates some kind of an empty Constructor
            ctor1IL.Emit(OpCodes.Call,
                typeof(object).GetConstructor(Type.EmptyTypes));

            // Pushing the arguments
            // that have to be assigned to the fields.
            for (int k = 0; k < Fields.Count(); k++)
            {
                //Load our Class
                ctor1IL.Emit(OpCodes.Ldarg_0);
                //Load the Param at Position k
                ctor1IL.Emit(OpCodes.Ldarg_S, k + 1);
                //Write it to our Field-Definition
                ctor1IL.Emit(OpCodes.Stfld, Fields[k]);

                //{
                //  int i = 0;
                //  string s = "irgendwas";
                //  ...
                //}


            }
            // Close the Constructor (like: return)
            ctor1IL.Emit(OpCodes.Ret);

            // Defines the set and get-Accessors
            for (int n = 0; n < ClassDef_tmp.Keys.Count; n++)
            {
                Type T1 = ClassDef_tmp.Values.ToArray()[n].GetType();
                Type RefType = T1.FullName == tb.FullName ?
                    typeof(object) : T1;




                PropertyBuilder pbNumber = tb.DefineProperty(
                        ClassDef_tmp.Keys.ToArray()[n],
                        PropertyAttributes.HasDefault,
                        RefType,
                        null);

                // Defines a compiler attribute. The attribute is used for tell
                // a PropertyGrid the category name
                CustomAttributeBuilder CAB = new CustomAttributeBuilder(
                    typeof(System.ComponentModel.CategoryAttribute).GetConstructor(new Type[1] { typeof(string) }),
                    new object[1] { name.Replace("Type", "") });
                pbNumber.SetCustomAttribute(CAB);



                MethodAttributes getSetAttr = MethodAttributes.Public |
                        MethodAttributes.SpecialName | MethodAttributes.HideBySig;

                //Definition des Get-Accessors

                MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
                        "get_Field",
                        getSetAttr,
                        RefType,
                        Type.EmptyTypes);

                ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();

                numberGetIL.Emit(OpCodes.Ldarg_0);
                numberGetIL.Emit(OpCodes.Ldfld, Fields[n]);
                numberGetIL.Emit(OpCodes.Ret);

                pbNumber.SetGetMethod(mbNumberGetAccessor);

                //Definition des Set_Accessors

                MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
                        "set_Field",
                        getSetAttr,
                        null,
                        new Type[] { RefType });

                ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
                // Load the instance and then the numeric argument, then store the
                // argument in the field.
                numberSetIL.Emit(OpCodes.Ldarg_0);
                numberSetIL.Emit(OpCodes.Ldarg_1);
                numberSetIL.Emit(OpCodes.Stfld, Fields[n]);
                numberSetIL.Emit(OpCodes.Ret);

                pbNumber.SetSetMethod(mbNumberSetAccessor);




            }
            CustomAttributeBuilder CAB1 = new CustomAttributeBuilder(
                typeof(TypeConverterAttribute).GetConstructor(new Type[1] { typeof(Type) }), new object[1] { typeof(VDTPropertyConverter) });
            tb.SetCustomAttribute(CAB1);

            CustomAttributeBuilder CAB1 = new CustomAttributeBuilder(
                typeof(SerializableAttribute).GetConstructor(new Type[1] { typeof(Type) }), new object[1] { typeof(SerializableAttribute) });
            tb.SetCustomAttribute(CAB1);

            Type t = tb.CreateType();

            // The following line saves the single-module assembly. This
            // requires AssemblyBuilderAccess to include Save. You can also write a program that has
            // a reference to the assembly, and use the DynamicType type.
            // 
            /*
            try
            {
                ab.Save(aName.Name + ".dll");
            }
            catch
            {
              //add
            }
            */


            object[] args = new object[ClassDef_tmp.Count];
            args = ClassDef_tmp.Values.ToArray();

            // Creates a Instance of our new class:-)
            object o2 = Activator.CreateInstance(t, args);




            return o2;
        }					

1:
2:
3:
4:
5:

    class Auto
    {
        public int A;
        public string B;
    }					

1:
2:
3:
4:
5:

    class Bahn
    {
        public bool C;
        public dictionary<string, int> D;
    }					

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:

class LogEntry
{
    // pattern um die Log-Zeile zu erkennen --> ANPASSEN
    public const string Pattern = "Zeit1|Zeit2|Objektname1|attributname1:attributtyp1|attributname2:attributty";

    public DateTime Zeit1 { get; private set; }
    public DateTime Zeit2 { get; private set; }
    public string Name { get; private set; }
    public Dictionary<string, string> Attribute ( get; private set; }

    private LogEntry(
    {
        Attribute = new Dictionary<string, string>();
    }

    public LogEntry CreateLogEntry(string line)
    {
       LogEntry logEntry = new LogEntry();
       string[] args = line.Split('|');

       logEntry.Zeit1 = DateTime.Parse(args[0]);
       logEntry.Zeit2 = DateTime.Parse(args[1]);
       logEntry.Name = args[2];

       for (int i=3; i < args.Length; i++)
       {
            string[] keyValue = args[i].Split(':');

            Attribute.Add(keyValue[0], keyValue[1]);
       }
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

string[] lines = File.ReadAllLines("Application.log");
List<LogEntry> logEntries = new List<LogEntry>();

foreach(var line in lines)
{
   if (IsRegex.Match(LogEntry.Pattern, line))
   {
      logEntries.Add(LogEntry.CreateLogEntry(line));
   }
}					

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:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Agls_New.Datenmodell;
using System.Xml;
using System.IO;
using System.Xml.Serialization;
using System.Text.RegularExpressions;

namespace Agls_New
{
   class Program

    {
        static void Main(string[] args)
        {



            string[] lines = File.ReadAllLines("Application.log");
            List<LogEntry> logEntries = new List<LogEntry>();

            foreach (var line in lines)
            {
                if (IsRegex.Match(LogEntry.Pattern, line))
                {
                    logEntries.Add(LogEntry.CreateLogEntry(line));
                }
            }
...