• Du befindest Dich hier:
• Community
• »
• Mitglieder
• »
• Seikilos
• »
• Beiträge von Seikilos

Was mir gerade auffällt, ein Teil der Frage ist noch offen, ob man bei Verletzung von Constraints mehr Details bekommen kann.

Ich muss sagen, ich bin irritiert.
Ich habe diese Werte bereits im Debugger betrachtet und sie waren damals immer 0 und 0.

Wahrscheinlich habe ich zu dem Zeitpunkt ein in-memory XML mit dem XDocument validiert, klar dass es dort keine Zeilen geben kann.

Danke.

Ich generiere XML Daten und muss auf der XSD Ebene eine Validierung durchführen.

Gängige Techniken wie XmlDocument.Validate, XDocument.Validate und XmlReader mit einem ValidationEventHandler sehen alle recht ähnlich aus:

public void Validate()
{
  var schemas = new XmlSchemaSet();
  schemas.Add("", fullXsdPath);
  var doc = XDocument.Load(metaXmlFile);
  doc.Validate(schemas,ValidationEventHandler);
}

public void ValidationEventHandler(object sender, ValidationEventArgs e)
        {
            switch (e.Severity)
            {
                case XmlSeverityType.Error:
                    Console.WriteLine("Error: {0}", e.Message);
                    break;
                case XmlSeverityType.Warning:
                    Console.WriteLine("Warning {0}", e.Message);
                    break;
            }

        }

Hallo,

wir haben eine executable, dessen Assembly version beim Bauen automatisch generiert wird:

[assembly: AssemblyVersion("1.1.*")]

.net zu .net waren die Anforderungen, klappt natürlich auch gut.

Jetzt gibts ein seitliches Requirement, dass ein gewisser Satz aus Befehlen auch ohne WCF gehen soll. Aktuell ist das mit einem manuellen TCP Listener gelöst, aber die Doppelung der Aufrufe ist umständlich, daher wollte ich mal gucken, ob ich WCF faken kann.
Damit Linux, oder nicht .net Technologie drauf zugreifen kann.

Da ist es fast einfacher, über Reflection das Interface generisch an den TCP Listener zu binden, aber dabei habe ich das Gefühl, als würde ich die Arbeit von WCF nochmal in schlecht machen :/

Hallo,

bezüglich des XML, muss der Request auch ein XML sein, oder ist die Anfrage eine URL im Sinne von .../GetMethodeAufInterace/Param1/Param2?

Ich hatte mit web requests und WebGet Attributen und der Konfig rumgespielt. Auf die http Seite des Service bin ich gekommen, aber ich hab keine Parameter Übergabe zusammenbauen können, die einen Sinn ergibt.

TCP ist ein wenig komplizierter, weil ich nicht genau sehen, was da rüber geht. Hab zwar den Traffic mitgeschrieben, aber die Requests konnte ich nicht reproduzieren, wenn ich diese mit nem TcpWriter wiederholt habe. Vor allem weil der Request eine URL darstellt, die in dem Intranet nicht mal gültig ist.

Ich denke das Hauptproblem ist, dass ich keine Ahnung von WCF habe und kein ASP.net einsetzen will.

Hallo,

gibt es eine Möglichkeit, in die WCF Kommunikation manuell einzugreifen?

Endpoints werden ja, wie in diesem Beispiel definiert

<endpoint address="net.tcp://localhost:8002/MyProject"  binding="netTcpBinding"  contract="SomeContract.IMyContract" />

Nur ein Hinweis, der eventuell in die richtige Richtung führt:
Meiner Meinung nach, müsstest du in der Lage sein, ein Style mit einem Trigger zu definieren, der auf die Row angewendet wird, wenn der korrekte Trigger, wie "BeginEdit"? gefeuert wird. Im Style kannst du dann die Farbe ändern.
(ungetestet)

Internal finde ich gut. Das könnte es sein.

Wenn es das übliche Vorgehen ist, stelle ich mich dem nicht entgegen, ich finde nur das casten in jeder einzelnen Methode der Logik etwas mühsam.

Bei der GUI stimme ich dem zu, dass ist elegant gelöst.

Hallo,
ich bin bei der Lösung unschlüssig.
Der Contract hat dann nur die Getter, das ist ein Vorteil, aber alle Operationen auf der Logik erfordern dann das casten in die private Klasse.

Ist das der übliche Weg?

Hallo,

bei einem Projekt habe ich ein Austauschobjekt, welches Projekt heißt und so aussieht:

    public class Project
    {
        public string Path { get; set; }
        public bool Active { get; set; }
    }

project.Active = false;
// Weitere Statewechsel, File IO, etc

Hallo herbivore,

danke für die Antwort. Ich bin bei meinen Versuchen auch zu einem ähnlichen Schluss gekommen.
Ich dachte, dass ich eventuell was übersehe, so etwas ist ja immer nur so lange nicht möglich, bis es einer macht :)

Mir geht es da genauso. Als ich im Delirium nach den Attributen gesucht habe, war ich auch der Meinung, dass es so

void M (String caller = [CallerMemberName])

Vor einiger Zeit hat Ralph Westphal das Konzept des RequestWithResponsePins vorgestellt. Da geht es um Event-Basierte Programmierung und dem Problem, dass das Abschicken einer Frage aus Methode A durch Events als Antwort in einer Methode B zurück kommt und damit die Geschäftslogik stückelt.

Um die Antwort in der gleichen Methode zu bekommen, in der die Frage gestellt worden ist, hat er die Klasse RequestWithResponsePin vorgestellt:

using System;

namespace RequestWithResponsePin
{
   public class RequestWithResponsePin<TRequest, TResponse>
   {
      public RequestWithResponsePin(TRequest data, Action<TResponse> responsePin)
      {
         Data = data;
         ResponsePin = responsePin;
      }

      public TRequest Data { get; private set; }
      public Action<TResponse> ResponsePin { get; private set; }
   }

   public static class RequestExtensions
   {
      public static void Request<TRequest, TResponse>(this Action<RequestWithResponsePin<TRequest, TResponse>> outputPin, TRequest data, Action<TResponse> responsePin)
      {
         outputPin(new RequestWithResponsePin<TRequest, TResponse>(data, responsePin));
      }
   }
}

public class EBCDemo
   {
      public event Action<RequestWithResponsePin<string, bool>> OnSomething;

      public void ProcessSomething(RequestWithResponsePin<string, bool> req )
      {
         var str = req.Data; // mach was

         // Antwort
         req.ResponsePin(true);
      }

      public void Start()
      {
         var result = false;
         // Event feuern und Antwort bekommen
         OnSomething.Request("mein input", output => result = output );

         Console.WriteLine("Antwort {0}", result);
      }
   }

 [STAThread]
      static void Main()
      {

         var ebcDemo = new EBCDemo();
         // Bind
         ebcDemo.OnSomething += ebcDemo.ProcessSomething;
         
         ebcDemo.Start();

      }

      public void ProcessSomething(RequestWithResponsePin<string, bool> req )
      {
         var str = req.Data;
         var res = await Task.Run(
            () =>
            {
               Thread.Sleep(3000);
               return true;
            }
         );
         req.ResponsePin(res);
      }

Hallo herbivore,

das war die Seite mit den Beispielen für Caller Attributes:
An Introduction to New Features in C# 5.0

Die hat nur eine furchtbare Sourceformatierung, aber immerhin sieht man wie Caller Attributes eingesetzt werden können.

Ah mist. Es ist C# 5.0 (Hab die Version verwechselt)

Was ich suchte sind die Caller*:

public void Log([CallerMemberName] string Message = "")
{
}

Vor einiger Zeit habe ich über die neuen .net 4.5 und C# 4.0 Features gelesen.
Darunter waren die optionalen Argumente.
Nun wurde in dem Zusammenhang ein nettes Feature aufgeführt, was ich einfach nicht mehr finden kann.

Es ging um eine Möglichkeit logging sehr bequem zu machen. Optionale Argumente sehen ja so aus:

public void Foo(string msg = "irgend ein string") {}

public void Log(string method = [Method]) {}

Log();

Hallo,
jetzt sehe ich es. Vorhin hatte ich den Abschnitt über Components wohl übersehen.

Danke

Hallo,
kannst du mir den Link geben?
Ich habe hier Overview of the .NET Framework und Getting Started with the .NET Framework nichts finden können

Danke

Hallo,

ich finde keine konkrete Information darüber, ob ich ein Plugin mit VS2012 und .net 4.5 schreiben kann, welches in einer in 3.5 geschriebener Anwendung läuft.

Die Applikation lädt die dll zur Laufzeit, die 4.5 Assembly wird nicht in der Applikation referenziert. Soweit ich gegoogelt habe, dürfte das nicht gehen.
Die Struktur sieht ungefähr so aus:
Applikation referenziert CommonInterface.dll beide sind 3.5
Plugin in 4.5 referenziert CommonInterface.dll
Applikation lädt zur Laufzeit Dlls im Ordner Plugions und sucht nach der jeweiligen Interface Implementierung.
Das Plugin selber soll nicht re-targeted werden, sondern nach Möglichkeit mit 4.5 laufen.
Wenn das Plugin jetzt laufen würde, weiß ich nicht, wie die Aufrufe von 3.5 nach 4.5 und wieder zurück behandelt werden.

Danke

Denkbare wäre ein Hintergrundprozess, der prüft, ob die Zielanwendung reagiert. Wenn sie es nicht mehr tut, spawnst du diese neu.

Prüfen, ob eine Anwendung noch reagiert geht mit der Google-Suche leicht zu finden. z.B Ermitteln, ob ein Prozess reagiert

Eine recht banale Antwort: Wenn du den Algorithmus oder das Verarbeiten nicht stückeln kannst, dann bleibt dir nicht viel mehr, als die Anwendung mit 64 bit zu kompilieren und soviel Arbeitsspeicher nach zulegen, bis die Datei als ganze gelesen werden kann.

Pagefile Größe könnte man Erhöhen, aber damit hast du keine Performance Vorteile gegenüber dem Stückeln. Auf Platte ist auf Platte

Hallo,
nimm eine For-Schleife mit dem Count der Einträge der Liste und setze jeden einzelnen auf unchecked.

Edit: Hier gibt es eine Liste der geheckten Elemente CheckedListBox.CheckedItems-Eigenschaft

Hallo,

die Meldung ist

Hallo,
ich habe hier ein interessantes Problem.
Ein Windows 7 64 bit Ultimate mit .net 3.5 und eine executable, bei der im IL-Disassembly

// Metadata version: v2.0.50727

Ich kenne Freemind (für MindMaps).
BizAgi Process Modeler für Workflows
IHMC CmapTools

Guck dir die mal an. Vielleicht von unten nach oben :)

Das ist trotzdem ungewöhnlich.
Wo ist denn die Far-clipping plane?

Wie weit sind die Objekte vom Nullpunkt entfernt?

Dictionary ist eine Art HashSet, bei dem zu jedem Hash Key ein Value zugewiesen wird.
Du brauchst also nur Dictionary<string, int>

Konkrete Antwort auf die Frage: Ja, da es generisch ist, kannst du auch Dictionary<HashSet<string>, int> schreiben, macht aber keinen Sinn.