Grosse Version angehängt:

ProcessList_Maximum.zip

Hallo gagagurge.

Diese Technik, die Du wahrscheinlich suchst, wird in den genannten Links verwendet bzw. beschrieben:

Search & Replace Tool
Funktionsplotter
Formeleditor
Prozesse in Console ausgeben.
Objekte an Laufzeit kompilierten Code übergeben oder auslesen (allgemeine Kommunikation)

Ich hoffe das hilft Dir weiter.

Sollte jemand noch weitere Ideen haben, sucht die besten Ergebnisse zusammen und postet sie hier.

dr4g0n76

EDIT: Und versuche mal bitte mehr anwendungstechnisch vorerst zu erklären, was Du tun möchtest. Vielleicht gibts ja eine ganz andere Lösung die gut passt.

Erklär doch mal etwas mehr über die Bedingungen.
Dann kann man zusammen vielleicht den Ausdruck auch reduzieren.
Meistens gehen die viel einfacher als man denkt.

und hast Du das Regex-Lab hier aus dem Forum dazu schon mal benutzt, um Deine Ausdrücke zu testen?

Hast Du schon mal unter Windows 8.1 probiert, ob dieselbe Tastenkombination mit anderen Programmen funktioniert? Oder evtl. selbst eins zum Testen geschrieben, dass Du mit Deinem anderen ansteuerst?

Ansonsten (falls Du das alles schon berücksichtigst, kannst Du es ja gerne auch ignorieren: )

Lies hier:

SendKeys Class

und such nach Fokus.
Es scheint, als ob das nur funktioniert, wenn das Fenster, dass Du bedienen willst im Vordergrund ist.

Ansonsten kannst Du auch über

http://www.pinvoke.net/default.aspx/user32.keybd_event

die Windows API mittels keybd_event bemühen.
Oder:

such nach SendKeys hier im Forum.

Java-Style-Enums in C#

Neulich bin ich über Java-Enums gestolpert.
Etwas erstaunt war ich, dass diese nicht äquivalent zu c# oder c++ sind, sondern im Gegenteil dazu noch viel mehr können! Dann kam die Frage auf, wie können wir uns dieses Konzept in C# zunutze machen?

Hier das Ergebnis:

Mit diesem Snippet (unten) kann ein Enum im Style von Java angelegt werden.
Angeregt wurde diese Idee unter anderem durch folgenden Post:

Java Enum - Oracle

Entweder kann der untere Code in ein Snippet-Editor für C# in Visual Studio eingefügt werden
oder einfach das Snippet unten aus dem Dateianhang herunterladen und die Dateiendung in ".snippet" umändern.

Ich denke hier ist es auch legitim Extension-Methods zu verwenden, um Java möglichst nahe zu kommen. Sie sollten im Idealfall andere Objekte nie stören, da Enums so gesehen keine Funktionen haben.

Bei Oracle gab es dazu folgendes Beispiel:

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }
}

Hier also das Snippet und unten noch ein Beispiel dazu, wie man einen Java-Style-Enum daraus erstellen kann und dieses benutzt.

public enum $Testenum$
{
}

public static class $Testenum$Extensions
{
    private static readonly IDictionary<$Testenum$, $Testenum$Data> _map;

	static $Testenum$Extensions()
    {
		_map = new Dictionary<$Testenum$, $Testenum$Data>() { 
			//Fill here like Concrete enum value: for example $Testenum$.Value1, new $Testenum$Data(constructor value1, constructor value2, constructor value3, ...)
        };
	}
	
	public static $Testenum$Data Get$Testenum$Data(this $Testenum$ _value)
    {
		if (!_map.ContainsKey(_value))
			throw new ArgumentOutOfRangeException("_map", "Unknown $Testenum$");	
		return _map[_value];
	}
		
	/*public static int GetValue(this $Testenum$ $Testenum$)
	{
		//Example function
		//just put your code here
		//return Get$Testenum$Data($Testenum$).$Testenum$DataFunctionName;
	}*/
}

public class $Testenum$Data
{
      public $Testenum$Data(/* insert your constructor parameters here */)
      {
	
      }
}

Hier also der Java-Style-Enum. Ich hab mit Absicht nicht die Planeten-Klasse genommen,
denn ich hoffe es probiert jemand mal aus. Sondern hier was gemacht, um z.B. in einem Abwasch Farben so als Int-Werte ausgeben zu können und ja ich bin mir bewusst, dass es in diesem Falle auch anders geht. 😃

  public enum Colorable
    {
        Red, 
        Green,
        Blue
    }

    public static class ColorableExtensions
    {
        private static readonly IDictionary<Colorable, ColorableData> _map;

        static ColorableExtensions()
        {
            _map = new Dictionary<Colorable, ColorableData>()
            {
                //Fill here like Concrete enum value: for example Colorable.Value1, new ColorableData(constructor value1, constructor value2, constructor value3, ...)
                {Colorable.Red, new ColorableData(Color.Red)},
                {Colorable.Blue, new ColorableData(Color.Blue)},
                {Colorable.Green, new ColorableData(Color.Green)}
            };
        }

        public static ColorableData GetColorableData(this Colorable _value)
        {
            if (!_map.ContainsKey(_value))
                throw new ArgumentOutOfRangeException("_map", "Unknown Colorable");
            return _map[_value];
        }

        public static int RGBValue(this Colorable Colorable)
        {
            //Example function
            //just put your code here
            return GetColorableData(Colorable).RGBValue;
        }
    }
    
    public class ColorableData
    {
        private readonly Color m_Color;
        public ColorableData(Color _color)
        {
            m_Color = _color;
        }

        public int RGBValue { get { return m_Color.ToArgb(); } }
    }

und zu guter letzt noch ein Beispiel für die Ausgabe:

  foreach (Colorable color in typeof(Colorable).GetEnumValues())
  {
         MessageBox.Show(color.RGBValue().ToString());
  }

Java Enum

Hallo "Bradley". 😉
Richtig cooles Projekt. Habe das zufällig heute gerade gesehen und gedacht:
"Oh, was ist das denn?".
Und dann in einem Rutsch diesen ganzen Thread gelesen.
Zu guter Letzt wollte ich dann in Deinem Forum stöbern wo ich dann mit folgender Botschaft rejected wurde:

"Dieses Board ist leider derzeit nicht verfügbar."

Ist das ein Fehler oder gibt es das momentan gerade wirklich nicht?
Registrieren funktioniert auch nicht. Ich kann es mir also so oder so nicht ansehen.

Was mir persönlich gefällt es gibt sozusagen alles. Forum, quasi ein Entwicklungs-Board
und diesen Thread hier. Es wirkt also so gesehen sehr füllig im Sinne von komplett und nicht nur wie ein Projekt das NUR in Kinderschuhen steckt.

Wenn Du dranbleibst wird das was.

Good luck! 😃

EDIT: Mir sind noch zwei Dinge aufgefallen:

Oben muss es in zumindest zwei Fällen "seid" und nicht "seit" heissen.
"seit" schreibt man immer nur in Zeitangaben, z.B. "Seit 1978"

Ach ja und oben steht: Das Kampfsystem ist rundenbasiert.
Darauf gehst Du nicht ein. Wieso Kampfsystem war die erste Frage, die in meinem Kopf auftauchte. Muss ich kämpfen? Oder muss ich nur mein Schiff reparieren oder was ist letztendlich die Aufgabe?

Mehr Infos. Bin zu neugierig. lechz. 😃
Oder "mehr Input!", wie Nummer 5 sagen würde. 😃

P.S.: Und man verzeihe mir meine ss Fehler, denn ich habe gerade eine Schweizer Tastatur, da gibt es diesen laut nicht. 😉

Ich habe ein Beispiel-Projekt angehängt im obersten Post, dann kann jeder ausprobieren und muss nicht erst beide Klassen in ein Projekt kopieren.

Auf jede der Funktionen die über die entsprechenden Buttons der Form gesetzt sind, sind Breakpoints gesetzt, so dass sich jeder in Ruhe anschauen kann was passiert.

Ich editiere den oberen Beitrag nochmals, so dass einige Dinge etwas klarer werden sollten.

Anmerkung:

Gerade erst bemerkt.
Die Klasse benutzt einen Namespace der sich DynamicFramework.Iterators nennt.

Das ist nichts anderes als die komplett unveränderte Lösung für Iteratoren von Herbivore auf:

Hilfreiche Iteratoren / Improving Foreach

EDIT: Damit lässt sich die Klasse benutzen und fehlerfrei kompilieren.

Jetzt können wir andere Parameter ausprobieren.

Das nächste Statement sollte die 5 Prozesse ausgeben, die am meisten Speicher verbrauchen. Angenommen das LINQ-Statement stimmt, erhalten wir sie auch:

ProcessList "(from p in System.Diagnostics.Process.GetProcesses() orderby p.PrivateMemorySize64 descending 
select p).Skip(0).Take(5).ToList()" /l

Zusätzlich ändern wir den Code in der Datei oben ab ( in processOutputDefinitionCode.cs):

auf

Console.WriteLine(_process.ProcessName + " " + _process.Id);

Da das alles zur Laufzeit geschieht, brauchen wir nichts neu kompilieren.
Nur Parameter und Datei ändern.

Natürlich könnten wir auch diesen Parameter von der Konsole übergeben, aber erstens wird das unübersichtlich Anführungszeichen zu escapen und evtl. zu lang für die Konsole.
Wer will kann das natürlich gerne einbauen.

Ausgabe mit folgender Definition:

ProcessList /l "from process in processes orderby process.Id select process"

in processOutputDefinitionCode.cs steht:

Console.WriteLine(Verbose(_process));

Beschreibung:

Vorneweg:

Das entsprechende Projekt ist an diesen Beitrag angehängt.
Es heisst deswegen Minimum, da es auch noch einen Befehl gibt der Wildcards und String-Matches unterstützt.
Wenn Bedarf besteht, poste ich hier natürlich gerne die "GROSSE" Version.

Mit diesem Kommandozeilentool können Prozesse ausgegeben werden.
Es entspricht in etwa der Funktion von Tasklist (s. Tasklist).

Es gibt 2 Dinge die verändert werden können:

Besonderheiten:

Ihr könnt LINQ-Ausdrücke als Parameter angeben, also z.B.:

ProcessList "from process in processes orderby process.ProcessName select process" /l

oder

ProcessList NameOrderedProcessList.txt /lf

dann wird der LINQ-Ausdruck aus dem entsprechenden File ausgelesen.

Zudem gibt es die Datei processOutputDefinitionCode.cs in der die Ausgabe definiert werden kann.

Die Technik dazu habe ich schon einmal in

[gelöst] Lambda Funktionen in einem Script bzw. zur Laufzeit kompilierten Code.

beschrieben, um Werte an zur Laufzeit kompilierten Code übergeben und wieder zurückbekommen zu können.

Hier in der LINQ-Action Klasse wird der LINQ Befehl zur Laufzeit kompiliert.
Dann kann über die Schnittstelle IScript.Run(CNode node) der LINQ Befehl aufgerufen werden.
Dort gibt es eine Schleife in der die Prozesse aufgelistet werden.
Die Ausgabe des Prozesses folgt aus dem 2. Script.

Untenstehend die Linq-Action Klasse und die LinqScript Klasse.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;

namespace ProcessList
{
    /// <summary>
    /// This implements the Gem.
    /// </summary>
    public class LinqAction : ConsoleAction
    {
        public override List<Process> Match(string linqExpression)
        {
            try
            {
                //See this class to see how it's done. Linq statement compiling during runtime.
                LinqScript scriptProcessLinq = new LinqScript(
                    "Test", linqExpression, 
                    "System.Core.dll", 
                    "mscorlib.dll", 
                    "system.dll", 
                    "ProcessList.exe", 
                    "System.Windows.Forms.dll");

                //Run runtime compiled script here, and return value 
                object ids = scriptProcessLinq.Run();

                //show what we got.
                IEnumerable processes = (IEnumerable)ids;
                foreach (object process in processes)
                {
                    OutputScriptSingleton.Instance.Run(new CNode(process));
                    this.m_aProcessList.Add((Process)process);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            return m_aProcessList;
        }

        public override string GetConsoleParameter()
        {
            return "l";
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProcessList
{
    public class LinqScript : CScript
    {
        private string m_sQuery = string.Empty;

        public LinqScript(string _sName, string sQuery, params string[] _aReferencedAssemblies)
            : base(_sName, _aReferencedAssemblies)
        {
            this.m_sFullSource =
@"using ProcessList;
using System.Diagnostics;
using System.Linq;
using System.Windows.Forms;
namespace MyProgram
{
    public class Test : IScript
    {
        public object Run(CNode node)
        {
            Process[] processes = Process.GetProcesses();
            var results = {0};
            return results;
        }
    }
}";

            m_sQuery = sQuery;
            this.m_sFullSource = this.m_sFullSource.Replace("{0}", m_sQuery);

            Compile(_aReferencedAssemblies);
        }

        public override object Run()
        {
            IScript script = m_CompilerResults.CompiledAssembly.CreateInstance("MyProgram." + m_sName) as IScript;
            object ids = script.Run(new CNode("egal"));
            return ids;
        }
    }
}

Benutzt Techniken u.a. aus:

[gelöst] Lambda Funktionen in einem Script bzw. zur Laufzeit kompilierten Code.

Command Line, Kommandozeile, Prozess,

Hallo Nicole.

Dazu fällt mir etwas ein.

Falls Du deswegen Komma und Punkt ersetzen willst, weil Du später mit diesen Zahlen Rechnen willst, empfiehlt sich unbedingt:

System.Globalization

Beachtung zu schenken.
Da in verschiedenen Ländern 1000er Trennzeichen und Komma verschieden sind. Sonst wirst Du immer mit Suchen und Ersetzen arbeiten müssen.
.NET und C# haben aber schon alles dazu an Board.

Kurz: Du solltest für String/Zahlen-Konvertierungen nie irgendeine Funktion "Mach Komma aus Punkt" oder umgekehrt benötigen.

Just my two cents.

dr4g0n76

Hier gibts ein gutes Blog zu genau dem Thema.
Ein Programm wird erarbeitet mit dem man

• Verzeichnisse auflisten
• Dateien transferieren
• Löschen

kann.

WPD Transferring Content

Wenn ansonsten mein Beispiel-Projekt fertig ist, kann ich es gerne anhängen.

Zitat:

einfach nur [...] wenn da zum Beispiel gefragt wird, ob es die Verschlüsselung auch höher als 512-bit gibt.

Zur Information: Es wurde schlicht und einfach noch kein höheres Verschlüsselungsverfahren auf dieser Welt erfunden. [...]

Aufgrund dieser Diskussion, die ich mitbekam - Aussage (gekürzt) - habe ich gedacht, das ist interessant zu wissen.

EDIT: Und danke, der selben Meinung war ich vorher auch schon, zumindest was die Schlüssel angeht.

Hallo.

Das Thema kam in einer Diskussion auf, _es gäbe keine Verschlüsselung mit mehr als 512-Bit, da noch keiner erfunden worden sei. _

Da hier nur das Wort Verschlüsselung benutzt wurde, sage ich hier:

• Es gibt Verschlüsselungsalgorithmen mit mehr als 512-Bit. (z.B. RSA 1024 Bit?)
• Es gibt auch Keys mit mehr als 512 Bit.

Auszug aus Wikipedia: Elliptic Curve Cryptography

Effizienz und Sicherheit
[...] Pollard-Rho-Methode, deren Laufzeit bei \mathcal{O}(2^{n/2}) liegt, wobei n die Bitlänge der Größe des zugrundeliegenden Körpers ist. Nach heutigem Kenntnisstand wird z. B. mit einer Schlüssellänge von 160 Bit eine ähnliche Sicherheit erreicht wie bei RSA mit 1024 Bit [...]

(hab ich mir damit was falsches rausgesucht oder ist das schon der Beweis [...] wie bei RSA mit 1024 Bit [...])

Wie liegt der Stand? Was wisst ihr darüber?

Hier möchte ich einfach nur meine Erfahrung und mein Wissen erweitern, um schlauer zu werden.

Danke. 😃

Beschreibung der Tabs:

Script Window

Links im Script Window wird momentan der übersetzte Code angezeigt.
Es gibt eine Klasse in der die Befehle vorhanden sind.
Hier können auch neue Befehle hinzuprogrammiert werden, die dann rechts
vom Splitter in der Textbox mit den nummerierten Zeilen erkannt werden.

Window Finder

Der Window Finder kann dazu benutzt werden, um die Klasse (Window Class)
eines Fensters oder den Titel zu ermitteln. Sobald auf das Häkchen "Window Finder
(Click to activate) geklickt wird, einfach nur die Maus bewegen.
Ebenso wird das Module und das Handle ermittelt, soweit möglich.

Macro Recorder Prefs

Hier können Mause-Klicks und Mausbewegungen aufgezeichnet werden,
wohl dem der zu faul ist ein Script zu schreiben.
(Diese Funktionalität ist noch nicht fehlerfrei gegeben)

Browser

Wird einige Funktionalitäten enthalten, um Dinge im Browser anzustellen.

Capture

Wird dazu benutzt, um Bilder aus der Zwischenablage einzufügen.

Debug-Output

Ist zumindest vom Namen her bisher selbsterklärend.

Custom Message Window

Kann später dazu benutzt werden, um eigene Windows Messages zu verschicken.

Short Cuts:

Strg-Umschalttaste-M fügt ein MouseMove Command mit den Standard Parametern zur aktuellen Mausposition hinzu.

Strg-Umschalttaste-C fügt ein Mausklickbefehl in das Script Window hinzu.

Übrigens kann, wenn eine Zeile mit % beginnt, C# und Script Code gemischt werden.
Will ich also z.B. mehrere Script-Befehle wiederholen, kann ich:

%for(int i=0;i>10;i++)
%{
MouseMove(1043, 462, 100, 10)
MouseClick()
Sleep(3000)
}%

Das Programm sieht so aus:

WindowsRemoteScripting

Ziel des Programms war damals bevor ich autoIT von MS online gekannt hatte, die gleichen Dinge per Script machen zu können.

Es kann z.B. folgendes gemacht werden:

• Mauszeiger bewegen
• Daten an serielle Schnittstelle senden
• Focus setzen
• Bestimmte Tasten(-Kombinationen) aktivieren oder in Fenster tippen
• Prozesse öffnen, z.B. Notepad usw.

Bsp.-Script:

/*Login Testseite*/

//MouseMove(908, 111, 100,10)
//MouseClick()
//WriteText("hello")
//Sleep(500)

//MouseMove(1068, 112,100,10)
//MouseClick()
//WriteText("blub19782")
//Sleep(500)
//WriteEnter()

/* Refresh actual Browser Window */
MouseMove(74, 47, 100,10)
MouseClick()

// Like it ! //
Sleep(3000)

MouseMove(421, 324, 100,10)
MouseClick()
Sleep(1000)

MouseMove(668, 288,100,10)
MouseClick()
Sleep(1000)

/* Close Window */
MouseMove(978, 18,100,10)
MouseClick()
Sleep(1000)

/* Confirm */
MouseMove(429, 410, 100,10)
MouseClick()

Maus bewegen, Mausklick, Mouse Click, Move Mouse Pointer, Prozess öffnen, auto IT Ähnlichkeit

Das Programm kann hier heruntergeladen werden:

https://windowsremotescripting.codeplex.com

Die nächste Version wird zusätzlich ein AddIn für Visual Studio sein.
Ich denke das macht evtl. mehr Sinn.

Dann können diese Suchen und Ersetzen Strategien im Editor von VS angewendet werden. Ich denke das macht die Benutzung besser.

Ich bin jetzt den Schritt gegangen und habe das Projekt auf

https://imagerecognition2.codeplex.com/

gehostet.

Damit nichts mehr verloren geht.

@herbivore

Nein, es geht hierbei nur um Filter, die die Farbwerte verändern.

Ja, das ist die Frage, wie das Photoshop z.B. macht.

Eine Deckung für den Effekt, ist bestimmt nicht das schlechteste für den Anfang.
Ich denke ich nehme Herbivores Vorschlag auf.

Ansonsten ist IMHO klar: Es müsste etwas mit den Parameterwerten bei den Filtern zu tun haben, ansonsten reicht mir erst mal der "Deckungsbeitrag".

Wie würdet ihr den Schnittpunkt zweier Orthogonalen ermitteln,
wenn:

1 Linie waagrecht ist und
1 senkrecht und

(Es gibt nur diesen einen Fall in der Anwendung)

die Geradengleichungsformen (bzw. Steigungsform, 2 Punkteform) nicht verwendet werden sollen?

Ich habe folgende Lösung (wurde auf diese Art verlangt, warum auch immer)

     
public static Point SimpleIntersection(ILineControl a, ILineControl b)
        {
            Point point = NoneIntersect;
            //one line vertical another horizontal
            if (a.StartPoint.Y == a.EndPoint.Y
                && b.StartPoint.X == b.EndPoint.X
                && (b.StartPoint.X > a.StartPoint.X && b.StartPoint.X < a.EndPoint.X) //point has also to be in interval of other linesegment
                )
            {
                point = new Point(b.StartPoint.X, a.StartPoint.Y); // then there lines hit
            }
            //exactly the other way round
            else if (a.StartPoint.X == a.EndPoint.X
                && b.StartPoint.Y == b.EndPoint.Y
                && (a.StartPoint.X > b.StartPoint.X && a.StartPoint.X < b.EndPoint.X) //point has also to be in interval of other linesegment
                )
            {
                point = new Point(a.StartPoint.X, b.EndPoint.Y); // then there lines hit
            }

            return point;
        }

Kommt jemand noch auf eine elegantere Lösung?

ich überprüfe mit dem Intervall ob der Punkt auf der Linie liegt jeweils speziell für vertikal oder senkrecht...

In Photoshop gibt es ja die Effektdeckung / Effektstärke / Filterstärke.
Keine Ahnung - im Moment - welches der richtige Begriff dafür ist.

Es geht darum, wenn ein Filter auf ein Bild angewendet wurde
und das Originalbild vorhanden ist, wie ist dann die Formel dazu, um den Filter auf das Originalbild abgeschwächt anzuwenden?

Ist das für jedes Pixel im RGB-Farbraum (wenn die Farbe als Vektor betrachtet wird)

A = Original 
B = Filter angewendet

(A - B) / 100, so dass

B'=A + ((A - B) / 100 * Stärke) 

?

Oder wird da eine andere Formel zugrunde gelegt?
Ich denke doch.

100 ist in dem Fall die Unterteilung.

Bisher hab ich aber nichts konkretes dazu gefunden.

Zusatzinfo:

Typkonvertierungen mit TypeConverter (Extension)

Mit untenstehender Klasse ist folgendes möglich:
(1. Version)

Arrays, Listen bzw. IEnumerables können konvertiert werden.
Von einem Typ in den anderen.
Selbst wenn die Klasse keinen entsprechenden AddRange-Befehl oder Konstruktor hat, ist das auch möglich.

Ich muss also nicht mehr schreiben:

Wenn z.B.

    //Complex conversions
            char[] a = new char[] { 'm', 'u', 'l', 't', 'u', 'm', 'e', 's', 'c' };
            byte[] b = new byte[] { 65, 66, 66, 65, 65, 66, 65, 66 };

            int[] resultIntArrayFromCharArray = (int[])typeof(int[]).Cast(a);
            int[] resultIntArrayFromByteArray = (int[])typeof(int[]).Cast(b);
            char[] resultCharArray = (char[])typeof(char[]).Cast(b);
            byte[] resultByteArray = (byte[])typeof(byte[]).Cast(a);
            //--------------------------------------------------------------------------
            //Convert from IEnumerable<Guid> to ObservableCollection<Guid>
            IEnumerable<Guid> guids = new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
            ObservableCollection<Guid> observableCollectionGuid = (ObservableCollection<Guid>)typeof(ObservableCollection<Guid>).Cast(guids);

            //Convert from ObservableCollection<Guid> to IEnumerable<Guid>
            ObservableCollection<Guid> observableCollectionGuid2 = new ObservableCollection<Guid>(new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() });
            IEnumerable<Guid> guids2 = (IEnumerable<Guid>)typeof(IEnumerable<Guid>).Cast(observableCollectionGuid2);

            //--------------------------------------------------------------------------
            //Simple conversion
            int intValue = 339;
            double? doubleValueCastedNullable = (double?)typeof(double?).Cast(intValue);

            intValue = 90943;
            double doubleValueCasted = (double)typeof(double).Cast(intValue); 

            double doubleValue = 7.0d;
            float floatValueCasted = (float)typeof(float).Cast(doubleValue);

            float floatValue = 3.09f;
            decimal decimalValueCasted = (decimal)typeof(decimal).Cast(floatValue);

            //--------------------------------------------------------------------------
            try
            {
                //at the moment an invalid cast exception is expected, when casting an array to one element
                string[] textValues = new string[] { "Hallo", "Hello", "Hola", "olá", "buna", "jak", "dag" };
                string sText = (string)typeof(string).Cast(textValues);
            }
            catch (InvalidCastException ex)
            {
                //so now we get an invalid cast
            }
            catch (Exception ex)
            {
            }

            //This will be casted, but at the moment makes no sense at all.
            //So one shouldn't do this.
            try
            {
                byte[] intValues = new byte[] { 7, 3, 9, 8, 5, 9 };
                int value = (int)typeof(int).Cast(intValue);
            }
            catch (InvalidCastException ex)
            {
            }
            catch (Exception ex)
            {
            }

            //--------------------------------------------------------------------------
            //This is possible: cast a single value to a list
            string textValue = "Hallo";
            List<string> sText2 = (List<string>)typeof(List<string>).Cast(textValue);

            //This is possible: cast a single value to a list
            Guid singleGuid = Guid.NewGuid();
            List<Guid> guidsOfSingleGuid = (List<Guid>)typeof(List<Guid>).Cast(singleGuid);

            intValue = 737;
            List<int> intsOfSingleInt = (List<int>)typeof(List<int>).Cast(intValue);

            bool trueValue = true;
            List<bool> boolsOfSingleBool = (List<bool>)typeof(List<bool>).Cast(trueValue);

         
            //--------------------------------------------------------------------------
            //This is also possible: Convert object to string: internally call object.ToString()
            intValue = 3457;
            string intValueCastedToString = (string)typeof(string).Cast(intValue);

using System;
using System.Runtime.CompilerServices;
using System.Collections;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using DynamicFramework.Iterators;

namespace DynamicFramework.TypeCast
{
    /// <summary>
    /// Use this class to do any type casts that would consume programming and code in one line.
    /// even casting like this is allowed:
    /// 
    /// 
    /// 
    /// </summary>
    public static class TypeCast
    {
        // This is the method exposing the rest of the functionality
        /// <summary>
        /// Casts the specified type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="obj">The object.</param>
        /// <returns></returns>
        public static object Cast(this Type type, object obj)
        {
            return GetConverter(type, obj)(obj);
        }

        /// <summary>
        /// Converters contains the cached converters, 
        /// so using once it might be slow, the second time a cached converter
        /// will be used if possible.
        /// </summary>
        private static readonly IDictionary<PairOfTypes, Func<object, object>> converters =
            new Dictionary<PairOfTypes, Func<object, object>>();
        
        private static readonly ParameterExpression convParameter =
            Expression.Parameter(typeof(object), "val");

        /// <summary>
        /// Gets the converter.
        /// </summary>
        /// <param name="targetType">Type of the target.</param>
        /// <param name="val">The value.</param>
        /// <returns></returns>
        /// This is the method with the "guts" of the implementation
        [MethodImpl(MethodImplOptions.Synchronized)]
        private static Func<object, object> GetConverter(Type targetType, object val)
        {
            var fromType = val != null ? val.GetType() : typeof(object);
            var key = new PairOfTypes(fromType, targetType);
            Func<object, object> res;
            if (converters.TryGetValue(key, out res))
            {
                return res;
            }

            bool bConverted = true;
            try
            {
                res = (Func<object, object>)Expression.Lambda(
                    Expression.Convert(
                        Expression.Convert(
                            Expression.Convert(
                                convParameter
                            , fromType
                            )
                        , targetType
                        )
                    , typeof(object)
                    )
                , convParameter
                ).Compile();
                converters.Add(key, res);
            }
            catch (InvalidOperationException ex)
            {
                bConverted = false;
            }
            catch (Exception ex)
            {
                bConverted = false;
            }
            if (!bConverted)
            {
                IList listTargetType = null;
                IEnumerable listSourceType = val as IEnumerable;
                if (listSourceType != null)
                {
                    if (targetType.IsArray)
                    {

//TODO: for silverlight, what to do if there is an interface...
#if !SILVERLIGHT
                        if (listSourceType.GetType().GetInterface(typeof(IList).Name) != null)
                        {
                            IList list = (IList)listSourceType;
                            int count = list.Count;
                            listTargetType = (IList)Activator.CreateInstance(targetType, count);

                            int i = 0;
                            foreach (object oElement in Iter.All(listSourceType))
                            {
                                //unbox if needed, don't know yet, how to do by reflection
                                if (oElement.GetType() == typeof(char) && GetBaseTypeOfGenericIEnumerableType(listTargetType.GetType()) == typeof(byte))
                                {
                                    listTargetType[i++] = (byte)(char)oElement;
                                }
                                else
                                {
                                    listTargetType[i++] = oElement;
                                }
                            }
                        }
#endif
                    }
                    else
                    {
                        if (targetType == typeof(string))
                        {
                            throw new InvalidCastException(); //this is invalid, because one doesn't know how to convert an array into one element here.
                        }
                        listTargetType = (IList)Activator.CreateInstance(targetType);

                        if (val.GetType() == typeof(string))
                        {
                            listTargetType.Add(val);
                        }
                        else
                        {
                            foreach (object oElement in listSourceType)
                            {
                                listTargetType.Add(oElement);
                            }
                        }
                    }
                    //still null? consider case converting ONE element on source into list of elements in target
                }
                else
                {
                    if (targetType.FullName.Contains(val.GetType().FullName))
                    {
                        Type baseType = GetBaseTypeOfGenericIEnumerableType(targetType);
                        listTargetType = (IList)Activator.CreateInstance(targetType);
                        listTargetType.Add(val);
                    }
                }
                if (targetType == typeof(string) && listTargetType == null)
                {
                    res = (Func<object, object>)(x => val.ToString());
                    converters.Add(key, res);
                    return res;
                }
                else if (targetType.IsGenericType 
                    && listTargetType == null
                    && targetType.Name.Contains("List`1"))
                {
                    listTargetType = (IList)Activator.CreateInstance(targetType);
                    listTargetType.Add(val);
                }
                res = (Func<object, object>)(x => listTargetType); //this will get us what we want
                //converters.Add(key, res);
            }
            return res;
        }

        //TODO: avoid this method, if possible, but for the moment it's perfect.
        /// <summary>
        /// Found no other way to do this yet.
        /// </summary>
        /// <param name="targetType"></param>
        /// <returns></returns>
        public static Type GetBaseTypeOfGenericIEnumerableType(Type targetType)
        {
            string[] elements = System.Text.RegularExpressions.Regex.Split(targetType.FullName, @",|\[\[");
            if (elements.Length > 1)
            {
                return Type.GetType(elements[1]);
            }
            else
            {
                return Type.GetType(elements[0].TrimEnd(']').TrimEnd('['));
            }
        }
#if !FRAMEWORK35
        /// <summary>
        /// Converts the specified original.
        /// </summary>
        /// <param name="original">The original.</param>
        /// <returns></returns>
        public static ObservableCollection<object> Convert(IEnumerable original)
        {
            return new ObservableCollection<object>(original.Cast<object>());
        }

        /// <summary>
        /// Converts the specified original.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="original">The original.</param>
        /// <returns></returns>
        public static ObservableCollection<T> Convert<T>(IEnumerable<T> original)
        {
            return new ObservableCollection<T>(original);
        }

        /// <summary>
        /// Converts the specified original.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="original">The original.</param>
        /// <returns></returns>
        public static ObservableCollection<T> Convert<T>(IEnumerable original)
        {
            return new ObservableCollection<T>(original.Cast<T>());
        }
#endif
        
        /// <summary>
        /// Find out how to really unbox!!!
        /// </summary>
        /// <param name="oElement"></param>
        /// <param name="sourceType"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        private static object Unbox(object oElement, Type sourceType, Type destinationType)
        {
            if (sourceType == typeof(char) && destinationType == typeof(byte))
            {
                oElement = (byte)(char)oElement;
            }
            return oElement;
        }

        // This class provides Equals and GetHashCode
        // for a pair of System.Type objects.
        private class PairOfTypes
        {
            private readonly Type first;
            private readonly Type second;
            public PairOfTypes(Type first, Type second)
            {
                this.first = first;
                this.second = second;
            }
            public override int GetHashCode()
            {
                return 31 * first.GetHashCode() + second.GetHashCode();
            }
            public override bool Equals(object obj)
            {
                if (obj == this)
                {
                    return true;
                }
                var other = obj as PairOfTypes;
                if (other == null)
                {
                    return false;
                }
                return first.Equals(other.first)
                    && second.Equals(other.second);
            }
        }
    }
}

Ist das auch Absicht:

var limit = 10;
limit = "five";

@inflames2k:

Ich sehe die Aufgabe als gelöst an,
für die entsprechenden Entities im vorgegebenen Modell wurde alles ausgegeben wie erwartet.

@inflames2k:

  string sMemberInfos = string.Empty;
    foreach (string sMember in sMemberInfos )
        sMemberInfos += String.Concat(sMember, Environment.NewLine);

Das lässt sich nicht übersetzen, wie ist das gemeint?

  string sMemberInfos = string.Empty;
    foreach (string sMember in sMemberInfos )

EDIT: kann mir ja was denken, nur wie Du es wirklich gemeint hast, da gibt es mehrere Möglichkeiten.

@Pinki: Hatte ich vergessen, habe ich ergänzt.

Es gilt für alles was aufrufbar ist. Danke für den Hinweis. :

Auf Herbivores Hinweis, stelle ich eine neue Aufgabe:

**Vorneweg: **
Ich denke die Aufgabe müsste in 50 Zeilen Code gelöst werden können.

Es geht darum, die Properties eines Objektes ALLE auszugeben und zwar derart:

Nehmen wir an, wir haben die folgenden Klassen (nicht als Text,
sondern wirklich im Visual Studio - vom Code aus benutz- und zugreifbar.

Bsp.:

EDIT: In class Book Fields durch Properties ersetzt

   public class Book
    {
        private int pages = -1;

        public Book(int pages)
        {
            this.pages = pages;
        }

        public string Title { get; set; }
        public int ReleaseYear { get; set; }
        public Author Author { get; set; }
        
        public int GetPages()
        {
            return pages;
        }
    }
	
	public class Author
       {
           public string FirstName { get; set; }
           public string LastName { get; set; }
           public string FancyName { get; set; }
           public string Name { get { return FirstName +" "+ LastName;} }
           public Biography Bio { get; set; }
       }
	
	public class Biography
        {
            public string Name { get; set; }
         }
	

Eine Methode ist zu schreiben, die folgendes ausgibt:

Wie der Aufrufende die Properties, bzw. Methoden aufrufen muss, um an den entsprechenden Wert bzw. Call zu kommen.
Dabei muss es egal sein, ob die Properties/Methoden/Fields mit "Get" oder "get_" anfangen, d.h. aus GetPages wird Pages,
ebenso werden die Klammern, wie z.B. bei GetPages() weggelassen, d.h. nur der reine Name und Punkte werden angegeben.
Das ganze muss auch noch dann funktionieren, wenn die Objektstruktur noch weiter erweitert wird.

Es wird immer der "Vollqualifizierte" Aufrufpfad ausgegeben.

**Stichwort: **

MemberInfo

Die Aufgabe darf rekursiv und iterativ gelöst werden.

**Bsp. für eine korrekte Lösungsausgabe: **

Book
Book.Title
Book.ReleaseYear
Book.Author
Book.Author.FirstName
Book.Author.LastName
Book.Author.FancyName
Book.Author.Name
Book.Author.Bio
Book.Author.Bio.Name
Book.Pages

Da in jeder Zeile sowieso Book vorkommt,
gilt auch, das Objekt kann weggelassen werden:

Ebenfalls korrekt:

Title
ReleaseYear
Author
Author.FirstName
Author.LastName
Author.FancyName
Author.Bio
Author.Bio.Name
Pages

Wenn also z.B. Bio später noch ein Unterobjekt mit

Bio.WeitereEbene.Entity1
Bio.WeitereEbene.Entity2

bekommen würde,

müsste die Ausgabe zusätzlich noch:

Author.Bio.WeitereEbene
Author.Bio.WeitereEbene.Entity1
Author.Bio.WeitereEbene.Entity2

enthalten.

Alles klar? Sonst bitte nachfragen.

Also, dann hier mal der Zwischenstand, damit man wenigstens sinnvoll damit arbeiten kann, folgendes geupdated:

**Filter: **

• der Filter Textbox können jetzt mehrere Zeilen angegeben werden.

• Jede Zeile wird momentan einzeln interpretiert.

• Die Ausgabe eines Filters wird dann als Eingabe für den nächsten interpretiert.

• die Reference von System.Globalization.dll wurde auf sysglobl.dll umgestellt,
  führte seltsamerweise auf manchen Systemen zu Fehlern.

Bsp.:

Text:

"MIR GEHT ES GUT."

Filter:

sInput.ToLower()
sInput.Filter(".")

Dann passiert intern folgendes:

Zu erst wird sInput.ToLower() ausgeführt:

"mir geht es gut."

**Dann: **

sInput.Filter(".")

Ergebnis also:

"mir geht es gut."

Damit lassen sich jetzt sehr komplexe Aufgaben erledigen.

TextBox- oben und unten:

• Die Returns werden wieder richtig angezeigt.

  Ich hatte vorher nur zwei TextBoxen,
  dann: oben RichTextBox unten TextBox,
  dadurch wurden die Returns falsch angezeigt.
  Jetzt sind beide vom Typ "RichTextBox"

P.S.: Warum sind die anderen DLLs eingebunden?
Ganz einfach: Weil auf lange Sicht, die Anwendung sich quasi von außen in andere integrieren können soll, z.B. in Word.

EDIT: Die Binaries finden sich im ersten Post.

Bitte mal mit dieser Version probieren.

Achtung: Diese benötigt jetzt 2 neue Dlls unter anderem auch die LowLevelGraphicsLibrary.

jop. häng ich hier an.

Update verfügbar: oben als Dateianhang.

Ausserdem sieht jetzt das gui so aus:

P.S.: Was ich mit den restlichen Controls mache, die sich unten übereinander schieben, wenn man das Fenster kleiner zieht, überlege ich noch.

@Th69:

Vom GUI her, stimmt sowieso einiges noch nicht und

Hallo dr4g0n76,

cooles Programm. So etwas ähnliches hatte ich auch immer schon mal vor, aber dann doch nicht die Muße dazu (mich hat unter Windows immer geärgert, daß es dort kein awk gibt).

Tja da muss man dann doch immer einiges selber machen. 😉
Mir kam die Idee eines Tages beim Programmieren, als ich mal wieder eine Flut von

Tab Return Delete

Sequenzenusw. einhämmern musste und genau wusste, ein regulärer Ausdruck oder normales Suchen & Replacen dauert entweder ewig oder ist überhaupt nicht möglich.

Und ebenfalls dauert das von Hand machen eben auch ewig.

Einen nervigen Fehler gibt es jedoch beim Resize des Fensters: die Controls sind dann übereinander (s. Anhang).

Das ist nicht nur einer, ich gebe auch zu um das GUI habe ich mich noch ziemlich wenig gekümmert. Aber die Funktionalität ist schon da.

Und wie startet man den Filter? Bei mir kommt bei "Process" immer nur "System.Void" im "Output". Hast du evtl. eine ältere Version hier hochgeladen (wie man auf dem Screenshot sieht, fehlt bei mir auch das rechte Teilfenster)?

Man klickt auf Process, bei den Menüitems - wenn Execute Immediately angeklickt ist - dann

Desweiteren fände ich eine Erklärung der einzelnen Menüpunkte (bes. unter "Misc" und "Prefs") nicht schlecht.

ich auch. 😉

Und schön fände ich es auch, wenn man den Filter auf eine Auswahl von Dateien ansetzen könnte (Batch-Mode).

Überlegt hatte ich das auch schon. Nur noch keine feste Entscheidung getroffen, wie das ablaufen soll.
Denn ich denke, der User möchte dann hier sehen was passiert.
Da ja doch ziemlich komplexe Vorgänge durchgeführt werden können.

Meine Idee(n) wäre(n) wie folgt:

1.) Der Benutzer kann auswählen, ob er sehen möchte, was passiert und kann jeden einzelnen Schritt bestätigen.

2.) Das Batch wird einfach ausgeführt und fertig.

Sowohl bei 1. als auch bei 2. wird dann hinterher angezeigt:

X Änderungen wurden in Y files gemacht. Und vielleicht ein Protokoll der Änderungen.

Edit: das rechte Teilfenster ist doch vorhanden - es war nur ganz klein (aber durch den Splitter konnte ich es dann hervorzaubern). Du solltest es aber standardmäßig größer machen (oder aber mittels eines Buttons oder Menüpunktes ein- und ausblendbar machen).

Jup. Eindeutig. Das nervt.
Ich hätte gerne ein Fenster mit mehreren Splittern, wird noch eingebaut.

Und jetzt sehe ich auch die Fehlermeldung:

Zitat:
Die Metadatendatei "system.globalization.dll" konnte nicht gefunden werden.

(darum wird also nur "System.Void" bei mir ausgegeben). Was könnte der Grund sein? Welche .NET-Version benötigt dein Programm (oder kann es etwas mit der Windows-Version zu tun haben- ich habe jetzt hier noch unter XP getestet)?

P.S. Mir ist auch aufgefallen, daß du im RAR-File noch die "LowLevelGraphics.pdb" und "LowLevelGraphics.xml" drinhast (also ohne die "LowLevelGraphics.dll"). Wenn du die entfernst, dann sollte das RAR-File auch deutlich kleiner werden (und die "*.vshost.exe"-Dateien benötigen die Anwender ja auch nicht).

Hier die Binaries.

EDIT: 29.03.2016

Binaries sind am Ende dieses Posts zum Download verfügbar. Einfach nach unten scrollen.

EDIT: 21.03.2016

Worum geht es hier? Was hat das Programm für einen Zweck? Es gibt immer wieder stellen im Programm-Code, bei Texten, CSV-Dateien wo einfach Suchen und Ersetzen nicht mehr ausreicht, aber man viele Male die gleiche Arbeit erledigen muss.

Zweck und Sinn des Programmes:

z.B.:
*Ich möchte aus jeder CSV Zeile ein Insert Statement für eine Datenbank generieren *Ich möchte alle Leerzeichen in Tabs umwandeln *Ich möchte alle \r\n durch \n ersetzen *Ich möchte die Länge des Textes wissen *Ich möchte die Zeichensetzung in einem deutschen Text auf eine bestimmte Weise korrigieren. *Ich möchte alle Worte einer Spalte hintereinanderhängen *Ich möchte eine HTML-Tabelle aus meinem CSV-Text erstellen *Ich möchte Spalten aus einem CSV-Text in Zeilen umwandeln oder umgekehrt. *Ich möchte Zeilennummern in meinen Text / Code hinzufügen. *Ich möchte Zeilennummern aus meinem Text / Code löschen *Ich möchte meinen XML -> JSON oder JSON -> XML wandeln *Ich möchte meinen XML Code formatieren *Ich möchte meinen XML Code minimieren (Strip whitespaces) *...

usw.

Immer wenn irgendwo eine Arbeit gemacht wird, wo ich merke, jetzt kommt tausendmal die Sequenz:

Cursor auf das nächste Wort, Leerzeichen löschen, nächste Zeile einfügen, Return drucken.

oder irgenetwas wo ich merke ich muss immer wieder das Gleiche tun, was aber einfach mit Suchen und Ersetzen nicht mehr geht,
dann kann es sinnvoll sein zu prüfen, ob sich der Einsatz dieses Programmes lohnt.

EDIT: 08.01.2014:

Das Projekt ist jetzt auf

http://SearchAndReplace.CodePlex.Com zu finden.

EDIT: 07.012016

Neueste Binary Files im letzten Beitrag angehängt.

EDIT: 04.01.2016

-

Ältere Binaries here:
https://www.dropbox.com/s/q1khqnsb58y5x0t/SearchAndReplace.rar

Hallo Community.

Da ich mich öfter mal mit ungewöhnlichen Search & Replace Vorgängen herumschlage, habe ich ein Programm geschrieben, das diese Lücken füllen soll.

Wie funktioniert es?

in Input kann ein Text eingegeben werden oder mit "From Clipboard" einfügen.

in Filter kann dann C# Code zur Laufzeit eingegeben werden, der sich auf die Variable sInput bezieht. sInput ist ein ganz normaler string.

Dieser hat auch Extensions Methods.
Wer möchte kann sich die Script-Klassen-Datei die die Methoden definiert selbst anpassen.
Das Script wird zur Laufzeit compiliert und dann mit dem Programm-Code in der TextBox Filter kombiniert.

Konventionen:
[...] = Auslassungszeichen

Kurzanleitung:

Results

Mit Results arbeiten

Der Regex-Befehl vor "->" erzeugt die Einzelergebnisse, auf diese kann über ra[Index] (ein Array) zugegriffen werden.

Also anstatt schreiben zu müssen:

Regex.Split(sInput, " ")[0].Reverse()+Regex.Split(sInput, " ")[1].Reverse()+Regex.Split(sInput, " ")[2].Reverse() [B][...][/B]

kann ich folgendes schreiben:

Regex.Split(sInput, " ") ==> ra[0].Reverse()+ra[1].Reverse()+ra[2].Reverse()+ra[3].Reverse()

(++foreach line[/u][/color]

Hiermit können Suchen/Ersetzen-Vorgänge realisiert werden, die sonst möglicherweise einen höheren Programmieraufwand benötigten.

Will ich z.B. an jede Zeile ein ">>" anhängen reicht ein einfaches

foreach line sInput+=" >>"

(++foreach result[/u][/color]

Manchmal kommt es aber noch vor, dass man etwas mit den Ergebnissen machen möchte.
Dann ist dieser Befehl wichtig.

Foreach result heisst das mit den "ra"-Variablen des Arrays gearbeitet wird.
Soweit verstanden?

(++Anmerkungen[/u][/color]

foreach result und foreach line können momentan nicht kombiniert werden.
ist durchaus sinnvoll und fällt mir gerade beim Schreiben auf. Aber dann natürlich noch nicht realisiert.

(++Module[/u][/color]

Module sind die Textdateien die später die Scripts aus dem Filter enthalten.
Beim erneuten Laden der Exe können diese über Menüpunkte aufgerufen werden.
Der Menüpunkt heisst dann einfach so wie der Dateiname.

(++Open Module Path[/u][/color]

Explorer wird dort geöffnet, wo die Script-Dateien liegen.

(++Execute Immediately[/u][/color]

Manchmal möchte man, dass das Script sofort ausgeführt wird,
dann ist Execute Immediately die richtige Option.

Momentan ist das Verhalten derart: Sobald getippt wird (TextChange-Event) wird sofort das eingegebene Script für den aktuell eingegebenen Text ausgeführt .

(++Monitor Clipboard[/u][/color]

Ist Monitor Clipboard selektiert wird das Clipboard überwacht.
So kann z.B. zusammen mit Execute Immediately ein Text sofort nach der eingegebenen Script Regel
verarbeitet werden.

(++Top Most[/u][/color]

Die CheckBox oben rechts Top Most ist denke ich selbsterklärend oder?
Das Fenster bleibt immer im Vordergrund.

(++Re-Input[/u][/color]

Der Ausgabetext (Ergebnis) in Textbox Output wird wieder in die TextBox Input geschrieben.
In manchen Fällen praktisch falls man z.B. kein so kompliziertes Script schreiben will. Man weiss aber, dass man durch mehrmaliges wiederholen des gleichen Scripts ans Ziel kommt.

(++Compiler Error Message Box[/u][/color]

Treten Compiler-Fehler auf, werden diese in einer MessageBox angezeigt wenn der Menüpunkt angehakt ist, ansonsten rechts im Fenster auf dem Tab "Compiler Results".

(Anmerkung: Dieses Tab wird erst mit der neu hochgeladenen Version sichtbar sein. Der untere Screenshot zeigt noch eine ältere Version)

Wer noch zusätzliche Funktionen braucht, die momentan so nicht so einfach bewerkstelligt werden können, kann in der

SearchAndReplaceMetaclassDefinition.txt

einfach Funktionen nach belieben hinzufügen.

Wenn ich dazu komme, werde ich auch noch einige Vorschläge machen.

Das ganze funktioniert ganz gut.
Mir fehlen auch noch viele Funktionen.

Toll wäre noch ein Typ der Bewerbung in der Art:

Euro Bewerbung / Deutschland / International

Dann benutze ich die Anwendung auf jeden Fall!

Sieht auch gut aus. Gut designed.

Wenn ich auf Tutorial klicke komme ich nicht mehr aus dem Fenster, es wird nicht geschlossen.

Meine Id sieht jetzt folgendermaßen aus, im Moment:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Linq.Expressions;

namespace TestMethodCalls.TestKlassen
{
    public class DelegateCreator
    {
        public static Delegate CreateDelegate(MethodInfo methodInfo)
        {
            return CreateDelegate(methodInfo, null);
        }

        public static Delegate CreateDelegate(MethodInfo method, object @object)
        {
            return Delegate.CreateDelegate
            (
                Expression.GetDelegateType
                (
                    method.GetParameters()
                        .Select(p => p.ParameterType)
                        .Concat(new Type[] { method.ReturnType })
                        .ToArray()
                ),
                @object,
                method
            );
        }
    }
}

Delegates kreieren.

und das ist die Zugriffsklasse:

 public class Access
    {
        private Process m_Process = null;

        CallDictionary m_CallDictionary = new CallDictionary();

        public Access(Process process)
        {
            m_Process = process;

            KeyValuePair<Type, Delegate> keyValuePair = CreateDelegateFromMethodName(m_Process, "get_KPIs", typeof(IDocumentItem));
            m_CallDictionary.Add(keyValuePair.Key, keyValuePair.Value);

            keyValuePair = CreateDelegateFromMethodName(m_Process, "get_Parts", typeof(IPart));
            m_CallDictionary.Add(keyValuePair.Key, keyValuePair.Value);
        }

        public T GetByID<T>(string id)
        {
            Delegate runtimeDelegate = m_CallDictionary[typeof(T)];
            object resultObject = runtimeDelegate.DynamicInvoke();

            Delegate cachedDelegate = null;
            foreach (object o in (IEnumerable)resultObject)
            {
                if (cachedDelegate == null)
                {
                    cachedDelegate = DelegateCreator.CreateDelegate(o.GetType().GetMethod("get_ID"), o);
                }

                if (string.Compare(cachedDelegate.DynamicInvoke().ToString(), id, true) == 0)
                {
                    return (T)o;
                }
            }
            //IEnumerable<T> enumvalues = o as IEnumerable<T>;
            return default(T);
        }

        private KeyValuePair<Type, Delegate> CreateDelegateFromMethodName(object o, string methodName)
        {
            MethodInfo methodInfo = o.GetType().GetMethod(methodName);
            return CreateDelegateFromMethodName(o, methodName, methodInfo.ReturnType);
        }

        private KeyValuePair<Type, Delegate> CreateDelegateFromMethodName(object o, string methodName, Type overrRideType)
        {
            MethodInfo methodInfo = o.GetType().GetMethod(methodName);
            Delegate runtimeDelegate = DelegateCreator.CreateDelegate(methodInfo, m_Process);
            Type type = overrRideType;
            return new KeyValuePair<Type, Delegate>(type, runtimeDelegate);
        }

//              MethodInfo methodInfo = process.GetType().GetMethod("get_KPIs");
//                Delegate runtimeDelegate = DelegateCreator.CreateDelegate(methodInfo, process);
//                m_CallDictionary.Add(typeof(IPart), runtimeDelegate);

    }
}

(Erster Wurf)

Jetzt kann z.B. mit

  IPart i = access.GetByID<IPart>("CA761232-ED42-11CE-BACD-00AA0057B223");

zugegriffen werden.

EDIT: Wird nichts gefunden, wird default(T) zurückgegeben

Genau TH69, die Interfaces haben hier leider nichts gemeinsam.

EDIT: Deswegen war mir auch klar, dass hier die Vorgehensweise so nicht funktionieren wird und der Compiler zu Recht meckert.

EDIT: Ja @ Th69 ein Beispiel ist super, klar gerne. Ich werde auch meine anderen Lösungen hier bereitstellen.

EDIT: @ TH69: Es kann später mal heißen IPart, IDocumentType, IDepartment
hab ich falsch reinkopiert. Es stehen nachher überall die gleichen Interfaces.

Also IDepartment wäre z.b. das 3. was hinzukommt.

Es gibt eine (eigene) Klasse Process.
Diese hat verschiedene Entities als IEnumerable<konkreter Typ> die zurückgegeben werden.

Unter anderem eine Auflistung von IEnumerable<IDocumentType>
eine Auflistung von IEnumerable<IPart> und weitere...

Allen gemeinsam sind Parameter die einfach nur "ID" heißen.
Vom Typ Guid. Meistens, nicht immer.

Gibt es irgendwie eine Möglichkeit damit den unteren Ausdruck zum Laufen zu bringen? Denn bisher meckert der Compiler, dass

quasi der Aufruf von IPart.ID und IDocumentType.ID ambiguous sind.
Es sollen auch noch mehr Interfaces als Where-Parameter hinzukommen.

  /// <summary>
        /// Gets the by identifier.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id">The identifier.</param>
        /// <returns></returns>
        public T GetByIDInternal<T>(string id) where T : IPart, IDepartment
        {
            object enumvalues = delegateCallsDictionary[typeof(T)].DynamicInvoke();
            //maybe here is a check needed if T or IEnumerable<T>
            return (T)Enumerable.FirstOrDefault<T>((IEnumerable<T>)enumvalues, partToSearchFor => partToSearchFor.ID.ToString() == id);
        }

P.S.:

die Initialisierung von

        private delegate IEnumerable<IPart> Parts();
        private delegate IEnumerable<IDocumentItem> KPIs();
        private IProcess process = null;

passiert momentan noch im Konstruktor als:

   /// <summary>
        /// Initializes a new instance of the <see cref="ObjectBehaviour"/> class.
        /// </summary>
        public ObjectBehaviour()
        {
            delegateCallsDictionary.Add(typeof(IPart), new Parts(delegate() { return process.Parts; }));

falls das ganze nicht möglich sein sollte, fällt mir momentan nur ein etwas in der Art wie:

      public T GetById<T>(string id)
        {
            if (typeof(T) == typeof(IPart))
            {
                foreach (IPart part in process.Parts)
                {
                    if (part.ID.ToString() == id)
                    {
                        return (T)part;
                    }
                }
            }
            else if (typeof(T) == typeof(ILabel))
            {
                foreach (IPart part in process.Parts)
                {
                    if (part.Title.ID.ToString() == id)
                    {
                        return (T)part.Title;
                    }
                }
            }
            else if (typeof(T) == typeof(IDocumentItem))
            {
                foreach (IDocumentItem documentItem in process.KPIs)
                {
                    if (documentItem.ID.ToString() == id)
                    {
                        return (T)documentItem;
                    }
                }
            }
            return default(T);
        }
            delegateCallsDictionary.Add(typeof(IDocumentItem), new KPIs(delegate { return process.KPIs; }));            
        }

zu machen und darin die Schleifen durch eine gegebene .NET Version zu eliminieren, was ich ziemlich unelegant finde.

Hintergrund des Ganzen ist generisch OHNE REFLECTION aufrufen zu können, je nach Typ des Objekts in dem man die ID des gesuchten Objekts vom Typ T angibt.

EDIT: Poste hier natürlich selbst die Lösung, wenn ich eine finde und suche nebenher weiter, vielleicht hab ich auch hier im Forum was übersehen, was ich nicht hoffe.

Wie wärs mit:

int x = 7;
int y = 11;
y = y + x - (x = y);

(Anspruch: Noch ein Einzeiler)

@xxMUROxx: Ist dann da irgendwie der Speicherplatz begrenzt und wie ist das? Aus der Webseite werde ich nicht wirklick schlau.

Es wird ja scheinbar in der Cloud gespeichert.
Ist das dann so wie bei Sourceforge abrufbar?

Und Version Control ist anscheinend GIT, weil da steht:

Version control (TFVC or Git)

Vom Namen her könnte man meinen, man könnte ganz normal mit Visual Studio TFS darauf zugreifen.

Ok, eine Lösung habe ich inzwischen gefunden, es ist möglich ein Tool zu schreiben (z.B. in C#) das in die XML-Kommentare des UML-Modells diese einträgt.

Dazu muss es eben aus dem Source-Code die XML-Kommentare extrahieren und in die entsprechenden Description Stellen in der UML-Datei einfügen.

Visual Studio erzeugt mittels des UML Class Designers im UML Editor verschiedene Dateien mit dem Namen "Irgendwas.uml".

Falls das jemand brauchen kann, werde ich wohl voraussichtlich ein Tool machen. Sobald ich dazu komme.

Gibt es im Visual Studio auf irgendeine Art folgende Möglichkeit:

1.) Aus dem Source mittels des Architecture Explorer eine Klasse in ein UML Modell ziehen (UML dafür wird erstellt)
2.) XML Kommentare übernehmen, so dass diese in der Description von den einzelnen Attributen stehen würden.

3.) UML ändern
4.) Code neu generieren.

Also quasi den Zwischenschritt zu sparen, die XML-Kommentare aus dem Code in jede einzelne Klasse für die UML zu ziehen.

Ich hoffe die Erklärung ist verständlich.

Im Internet habe ich dazu bisher nichts gefunden. Hier im Forum auch nicht.

Bisher ist das Verhalten so:

Im UML ist kein Kommentar mehr vorhanden, auch wenn dieser vorher im Source Code korrekt vorhanden war. D.h. beim Neugenerieren (vom UML Editor ausgehend) sind alle XML-Kommentare weg.

Bsp.:

        /// <summary>
        /// Gets or sets the title.
        /// </summary>
        /// <value>
        /// The title.
        /// </value>
        public ILabel Title
        {
            get;
            set;
        }

wenn ich jetzt also daraus im UML Editor ein Symbol für die Klasse mache, sollte also z.B. im Attribut-Editor für Title "The Title" drinstehen.

Das passiert aber nicht.

EDIT: Sollte ich in der Zwischenzeit selbst eine Lösung finden, werde ich sie selbstverständlich hier posten.

@Palladin:

Als Liste geht ja schon, s. o. nur als IEnumerable<T> da krachts gleich wenn Du

XmlSerializer xmlSerializer = new XmlSerializer(typeof(Process));
Process process = xmlSerializer.Deserialize() as Process

schreibst.

Dann kommt so was in der Art wie > Fehlermeldung:

"Fehler Reflecting Process [...]-[...] Schnittstelle kann nicht serialisiert werden"

@Abt: Danke. Auf dem gleichen Stand bin ich bisher auch, wie ja schon im Eingangspost (be-)geschrieben.

Die Yaxlib kommt sowieso nicht in Frage, weil sie LINQ benutzt.

Ausserdem vergessen zu erwähnen:
Ich habe hier ausnahmsweise ein Projekt wo ich .NET 2.0 benutzen muss.

(Verwendet wird das ganze später in SharePoint, das ist hier nicht relevant)

Ein Objekt vom "Typ" Process aus einer XML-Datei soll deserialisiert werden.

Existiert eine Möglichkeit, die untere Klasse so zu deserialisieren, dass

IEnumerable<Part> Parts

in der Klasse bestehen kann?
Ich habe bisher keine gefunden. Macht IMO auch nicht viel Sinn.

Denn wenn ich das nicht mache, meckert verständlicherweise der XMLSerializer, dass

IEnumerable<Part> Parts

vom Typ Schnittstelle nicht serialisiert werden kann. Logisch.

Denn wenn ich Parts auf

List<Part> Parts

umändern würde, dann geht alles. Dann kann ich nämlich auch IXmlSerializable implementieren, um Sonderfälle zu behandeln. Würde dann alles bisher soweit wunderbar funktionieren.

Leider darf ich momentan den Code der Klasse Process und alles was sie beinhaltet nicht ändern.
(Ist kein privates Projekt)

Momentan fällt mir dazu nur ein eine neue Klasse, die von XMLSerializer abgeleitet ist zu schreiben, weiter mit den XMLAttributen herumzuprobieren (hab bisher keine brauchbare Lösung gefunden).

So sieht das XML aus:

<Process>
  <CSF>Test Text</CSF>
  <ID>07cc89ae-05d7-41d4-92d5-b276de8ca39e</ID>
  <Parts>
    <Part>
      <ID>d5bbe94e-062a-4aa5-ba9f-abdc185bddf7</ID>
    </Part>
  </Parts>
</Process>

Folgende Klassen sind involviert:

public class Process
{
	public string CSF
	{
		get;
		set;
	}

        //[DataMember(Name = "Parts")]
        public IEnumerable<Part> Parts
        {
            get;
            set;
        }
}

public class Part// : IXmlSerializable
{
        public object ID
        {
            get;
            set;
        }
}

Ich hab hier mal gesucht und das hier zum kommerziellen Bereich gefunden (andere Ergebnisse hab ich bisher nicht gefunden):

Komerzielles SourceCode Hosting

Welche kostenlose Online Plattformen wie SourceForge, Git Hub, Google Code, Codeplex oder sonstige benutzt ihr?

Mich würde eine Plattform interessieren mit der ich

VS 2012
Das neueste Ankh
und das neueste Tortoise SVN benutzen kann.

Hat speziell in Richtung Subversion jemand Erfahrung?

Ich hab jetzt SourceForge mit Git ausprobiert und Sourceforge mit SVN,
trotz dem Lesen aller Dokus usw. bekomme ich es gerade nicht hin, von VS 2012

aus ein Projekt ins Online Repository hochzuladen.

Ich hab bisher nur eins hinbekommen:

Online auf den Browser gehen und die einzelnen Files hinzufügen,
ich möchte aber doch schon natürlich die Möglichkeiten nutzen und nach Möglichkeit mit Ankh Projekte einchecken.

Hat ja natürlich auch für den User hier im Forum den Nutzen, dass er sich das ganze aus dem Visual Studio oder per Zip etc. etc. selbst ganz einfach runterladen kann.

EDIT: lt. Sourceforge soll ja es ja - je nach benutzter Plattform - so möglich sein:

Services

Projects are provided access to a number of hosts. Access to the project shell and CVS servers is automatically provided to project members listed as developers. 

Project shell server
shell.sourceforge.net

Project CVS server
PROJECTNAME.cvs.sourceforge.net

Project Subversion server
PROJECTNAME.svn.sourceforge.net