Hallo,
ein WebClient sendet erst ca 15-20 Sekunden nach dem Aufruf der DownloadString Methode die Anfrage. Die Daten werden dann zwar empfangen, aber ich kann die Wartezeit nicht nachvollziehen. Es liegt nicht am Server, dieser antwortet sofort nachdem die Anfrage viel zu spät versendet wurde. Im Browser funktioniert auch alles ohne Verzögerung. Woran kann soetwas liegen?

verwendetes Datenbanksystem: JSON
Hallo,
Eine API gibt mir folgendes JSON zurück:

{
   "coord":{
      "lon":145.77,
      "lat":-16.92
   },
   "weather":[
      {
         "id":803,
         "main":"Clouds",
         "description":"broken clouds",
         "icon":"04n"
      }
   ],
   "base":"cmc stations",
   "main":{
      "temp":293.25,
      "pressure":1019,
      "humidity":83,
      "temp_min":289.82,
      "temp_max":295.37
   },
   "wind":{
      "speed":5.1,
      "deg":150
   },
   "clouds":{
      "all":75
   },
   "rain":{
      "3h":3
   },
   "dt":1435658272,
   "sys":{
      "type":1,
      "id":8166,
      "message":0.0166,
      "country":"AU",
      "sunrise":1435610796,
      "sunset":1435650870
   },
   "id":2172797,
   "name":"Cairns",
   "cod":200
}

Ich bin aber nur an einigen Eigenschaften interesiert:

  public class Weather
    {
        #region properties
        [JsonProperty(PropertyName = "main",Required = Required.Always)]
        [JsonConverter(typeof(StringEnumConverter))]
        public WeatherCondition Condition { get; set; }
        // .... //
        #endregion
    }

Ich möchte hier aber die Eigenschaft des Objekts "main" deserialisieren, nicht das main Object. Wie kann ich hier sozusagen den "Pfad" zu der Eigenschaft angeben.

Ich habe mich in meinem letzten Post vertan, der Converter wird noch aufgerufen, hatte den Haltepunkt falsch gesetzt.
-> Egal ob der Pfad angeben ist oder nicht, wird immer null übergeben.
Im Anhang ist das Testprojekt, habe versucht das Problem mit möglichst wenig Code darzustellen. Danke 👍

@Palladin007 Wenn ich den Pfad wegnehme wird eine InvalidOperation Exception geworfen, ohne Source wird der Converter gar nicht mehr aufgerufen. Ist das normal?
@MrSparkle Das ist meine Umsetzung von dem Post von kurzem. Ich brauchte ja eine Eigenschaft um an diese zu binden. Ich habe 3 Listen. habe statt 3 mal das gleiche mit anderem Namen dafür entschieden einen generischen "Wrapper" zu nehmen. Dieser hat einfach nur eine Value Eigenschaft an die ich dann binden kann.

PS: Wenn es dir überhaupt nicht klar ist was ich ereichen wollte, hoffe ich das ich das Ziel nicht all zu weit verfehlt habe 😉

Ich lege ja die Datenquelle fest. Und diese heißt auch ListPaths. Das Ziel der Binding ist es diese Liste zu "wrappen" um sie im View darstellem zu können. Und ich setzte vor der Binding die Eigenschaft auf eine leere Collection.
Vieleicht gebe ich hier noch ein bisschen Kontext:

        public ObservableCollection<string> ListPaths
        {
            get
            {
                return _listPaths;
            }
            set
            {
                if (_listPaths != value)
                {
                    _listPaths = value;
                    OnPropertyChanged("ListPaths");
                }
            }
        }

        public ObservableCollection<Wrapper<string>> WrappedListPaths
        {
            get
            {
                return (ObservableCollection<Wrapper<string>>)GetValue(WrappedListPathsProperty);
            }
            set
            {
                SetValue(WrappedListPathsProperty, value);
                OnPropertyChanged("WrappedListPaths");
            }
        }

Hallo,

public static readonly DependencyProperty WrappedListPathsProperty = DependencyProperty.Register("WrappedListPaths", typeof(ObservableCollection<Wrapper<string>>), typeof(ViewModel));

Diese Eigenschaft binde ich an eine Eigenschaft aus dem Model:

 Binding wrapListPaths = new Binding();
            wrapListPaths.Source = Processor;
            wrapListPaths.Path = new PropertyPath("ListPaths");
            wrapListPaths.Mode = BindingMode.OneWayToSource;
            wrapListPaths.Converter = new WrapCollectionConverter<string>();
            wrapListPaths.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
            BindingOperations.SetBinding(this, WrappedListPathsProperty, wrapListPaths);

An den Konverter wird egal wie ich die Eigenschaft davor gesetzt habe aber immer null übergeben. Woran liegt das?

Ich kann euch nicht fanz folgen. Ich soll ein Viewmodel nur füe die string Objekte erstellen und dann einfach eine NameViewModel Collection verwenden? @MrSparkle Du bindest an eine Property im Haupt-Viewmodel? Woher weiß die Eigenscgaft welches Element ausgewählt ist?

Hallo,
ich habe eine Listbox, die an eine Observable<string> Collection gebunden ist:

<ListBox Height="100" ItemsSource="{Binding Items}" Name="Listbox">

und eine Textbox mit der das ausgewählte Element bearbeitet werden kann:

<TextBox Text="{Binding ElementName=Listbox,Path=SelectedItem,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"/>

Wenn ich nun ein Element auswähle kann ich mich zwar in der Textbox den Cursor bewegen, aber nichts Eingeben oder Löschen. Mit ListboxItems funktioniert alles, ich kann auch aus der Code-Behind problemlos Elemente editieren.

Das Thread ist schon einige Tage alt, ich lese die letzten Antworten aber erst jetzt und möchte noch einmal darauf eingehen.
@Abt Nach kurzem Nachsehen vieleicht der folgende Namespace: http://www.r3turnz.com/2016/openSearch/index. Das Version würde ich dann über ein Attribut im Dokument angeben.
@ErfinderDesRades Wenn ich darüber nachdenke, hast du recht. Eine kurze Vorüberlegung:
In jede Zeile wird ein Dateiname geschrieben. Um einen Ordner zu signalisieren füge ich am Ende der Zeile ein '/' hinzu. So kann das Programm sich den Pfad zusammensetzen. Um einen komplett neuen Pfad anzugeben würde ich ein ':' vor die Zeile schreiben.

Hallo,
ich habe nun die asynchrone Pipeline Implementation umgesetzt. Diese Variante kommt wenn dann auf gleiche, wenn nicht sogar schlechtere Performance als die ohne asynchrone Operationen. Da sie aber auf zwei Threads bzw. Tasks verteilt läuft, müsste sie doch eigentlich schneller laufen?(Ich poste nur den wichtigen Teil, damit der Code nicht unnötige lang wird):

 public async Task  CreateIndex(string[] directoryPaths, string[] excludeDirectories, string[] preferDirectories,CancellationToken ctoken)
        { 
               if (disposed) throw new ObjectDisposedException(null);
            bool hasPreferred = false;
            //Validierung//



            WriteIndexStart(SupportedFileVersion);
            _writer.WriteStartElement("entries");
            //create tasks//
            TaskFactory factory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None);
            BlockingCollection<string> fileBuffer = new BlockingCollection<string>(64);
            //prefered directories//
            if (hasPreferred)
                {
                    //makes reading easier//
                    _writer.WriteAttributeString("hasPreferred", "true");
                    _writer.WriteStartElement("preferred");
                    Task preferFileSearcher = factory.StartNew(delegate() 
                    {
                        EnumerateFolders(preferDirectories, excludeDirectories, fileBuffer, ctoken);
                    }
                    );
                    Task preferFileWriter = factory.StartNew(delegate () 
                    {
                         WriteFiles(fileBuffer, ctoken);
                    });
                    await Task.WhenAll(preferFileSearcher, preferFileWriter);
                    _writer.WriteEndElement();
                    fileBuffer = new BlockingCollection<string>(256);
                }
                else _writer.WriteAttributeString("hasPreferred", "false");
                _writer.WriteStartElement("other");
   
                Task fileSearcher = factory.StartNew(delegate ()
                {
                    EnumerateFolders(directoryPaths, excludeDirectories, fileBuffer, ctoken);
                });

              Task fileWriter = factory.StartNew(delegate () { WriteFiles(fileBuffer, ctoken); });
                await Task.WhenAll(fileSearcher, fileWriter);
                _writer.WriteEndElement();
                _writer.WriteEndElement();
                WriteIndexEnd();
        }

Ich verwende async await, um nicht einen Thread im Leerlauf zu haben, während er mit WaitAll() auf die IO-Threads wartet. Die eigentlichen Fragen sind wie zu erwarten:
Wo könnte man den Stil der Implementation verbessern?
Wieso ist die Performance im Verhältnis zur synchronen Variante "gleich"?

Da in diesem Forum funktionierender Code verlangt wird:

    public class IndexerThreaded : IDisposable,INotifyPropertyChanged
    {
        #region fields
        XmlWriter _writer;
        #endregion
        #region properties

        public long FileCount { get; private set; }
       
        private string _currentDirectory;

        public string CurrentDirectory
        {
            get { return _currentDirectory; }
            set
            {
                _currentDirectory = value;
                OnPropertyChanged(new PropertyChangedEventArgs("CurrentDirectory"));
            }
        }
        public static Version SupportedFileVersion = new Version(1, 0);
        public const string IndexNamespaceURI = "http://www.r3turnz.com/index";
        #endregion
        #region events
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs args)
        {
            var handler = PropertyChanged;
            if(handler != null)
            {
                PropertyChanged(this, args);
            }
        }
        #endregion
        #region constructors
        public IndexerThreaded(string indexPath)
        {
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.NamespaceHandling = NamespaceHandling.OmitDuplicates;
            settings.WriteEndDocumentOnClose = true;
            settings.Encoding = Encoding.UTF8;
            _writer = XmlWriter.Create(indexPath,settings); 
        }
          public IndexerThreaded(string indexPath ,XmlWriterSettings settings)
        {
            _writer = XmlWriter.Create(indexPath, settings);
        }
        #endregion
         public async Task  CreateIndex(string[] directoryPaths, string[] excludeDirectories, string[] preferDirectories,CancellationToken ctoken)
        {
            if (disposed) throw new ObjectDisposedException(null);
            bool hasPreferred = false;
            //validation and optimization of the parameters//
            if (directoryPaths.Length < 1) throw new ArgumentException("A search path must be provided");
            directoryPaths.Distinct();

            if (excludeDirectories != null && excludeDirectories.Length > 0)
            {
                excludeDirectories.Distinct();
               if(directoryPaths.Intersect(excludeDirectories).Count() > 0) throw new ArgumentException("A directory is contained in the exclude list!");
            }
            if(preferDirectories != null && preferDirectories.Length > 0)
            {
                preferDirectories.Distinct();
                if (preferDirectories.Intersect(excludeDirectories).Count() > 0) throw new ArgumentException("A directory is contained in the exclude list!");
                hasPreferred = true;
            }

            WriteIndexStart(SupportedFileVersion);
            _writer.WriteStartElement("entries");
            //create tasks//
            TaskFactory factory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None);
            BlockingCollection<string> fileBuffer = new BlockingCollection<string>(64);
            //prefered directories//
            if (hasPreferred)
                {
                    //makes reading easier//
                    _writer.WriteAttributeString("hasPreferred", "true");
                    _writer.WriteStartElement("preferred");
                    Task preferFileSearcher = factory.StartNew(delegate() 
                    {
                        EnumerateFolders(preferDirectories, excludeDirectories, fileBuffer, ctoken);
                    }
                    );
                    Task preferFileWriter = factory.StartNew(delegate () 
                    {
                         WriteFiles(fileBuffer, ctoken);
                    });
                    await Task.WhenAll(preferFileSearcher, preferFileWriter);
                    _writer.WriteEndElement();
                    fileBuffer = new BlockingCollection<string>(256);
                }
                else _writer.WriteAttributeString("hasPreferred", "false");
                _writer.WriteStartElement("other");
   
                Task fileSearcher = factory.StartNew(delegate ()
                {
                    EnumerateFolders(directoryPaths, excludeDirectories, fileBuffer, ctoken);
                });

              Task fileWriter = factory.StartNew(delegate () { WriteFiles(fileBuffer, ctoken); });
                await Task.WhenAll(fileSearcher, fileWriter);
                _writer.WriteEndElement();
                _writer.WriteEndElement();
                WriteIndexEnd();
        }
        #endregion
        #region xml methods
        private void WriteIndexStart(Version fileVersion)
        {
            _writer.WriteStartDocument();
            _writer.WriteStartElement("in", "index", IndexNamespaceURI);
            _writer.WriteAttributeString("formatVersion", fileVersion.ToString());
        }   
        private void WriteIndexEnd()
        {
            _writer.WriteStartElement("summary");
            _writer.WriteStartElement("fileCount");
            _writer.WriteValue(FileCount);
            _writer.WriteEndDocument();
        }

        //writer file entry//
        private void WriteFileToIndex(string file,string fileName)
        {
            _writer.WriteStartElement("e");
            _writer.WriteAttributeString("n", file);
            _writer.WriteCData(file);
            _writer.WriteEndElement();
        }
        #endregion
        #region enumeration
        private void EnumerateFolder(string folder, string[] excludeDirectories, BlockingCollection<string> fileBuffer,CancellationToken ctoken)
        {
                    fileBuffer.Add(folder, ctoken);
                    foreach (var file in Directory.EnumerateFiles(folder))
                    {
                        ctoken.ThrowIfCancellationRequested();
                        fileBuffer.Add(file, ctoken);
                        FileCount++;
                    }
                    string[] subDirs = Directory.GetDirectories(folder).ToArray();
                    if (excludeDirectories != null)
                    {
                        subDirs = Directory.EnumerateDirectories(folder).Where(fold => !excludeDirectories.Contains(folder)).ToArray();
                    }
                    foreach (var subDir in subDirs)
                    {
                try
                {
                    EnumerateFolder(subDir, excludeDirectories, fileBuffer, ctoken);
                }
                catch (UnauthorizedAccessException) { }
                catch(FileNotFoundException) { }
                catch(DirectoryNotFoundException) { }
            }
        }
        private void EnumerateFolders(string[] folders,string[] excludeDirectories, BlockingCollection<string> fileBuffer,CancellationToken ctoken)
        {
            try
            {
                foreach (var folder in folders)
                {
                    CurrentDirectory = folder;
                    EnumerateFolder(folder, excludeDirectories, fileBuffer, ctoken);
                }
            }
            catch (OperationCanceledException) { }
            finally
            {
                fileBuffer.CompleteAdding();
            }
        }
        private void WriteFiles(BlockingCollection<string> fileBuffer, CancellationToken ctoken)
        {
            try
            {
                foreach (var file in fileBuffer.GetConsumingEnumerable(ctoken))
                {
                    ctoken.ThrowIfCancellationRequested();
                    WriteFileToIndex(file,Path.GetFileNameWithoutExtension(file));
                }
            }
            catch(OperationCanceledException) { }
        }
        #endregion
        #region disposing
        bool disposed = false;
        public void Dispose()
        {
            if (!disposed)
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }
        }
        protected virtual void Dispose(bool isSafetoDisposeObjects)
        {
            if (isSafetoDisposeObjects)
            {
                _writer.Close();
            }
            //unmanaged//
        }
        ~IndexerThreaded()
        {
            Dispose(false);
        }
        #endregion
    }

Ich habe jetzt mal alle Dokumentationselemente entfernt, mit ihnen wurde sehr unübersichtlich.

Noch eine Rückfrage:
Was ist mit Oversubsrciption der Hardware Threads gemeint?
Ich habe einen Thread der etwa 1,5 Minuten läuft, hier also auf jeden Fall Long Running. Dieser hat 2 IO Tasks, wobei der zweite auf den ersten wartet (-> Long Running). Praktisch: Es geht um einen Datei-Indexing Algorithmus, wobei der erste Task die Dateien sucht, während der zweite diese schreibt. (Hier würde ich Async und Await verwenden) Würde man das so umsetzen?

LG

Hallo,
es wird ofters erwähnt, dass es besser wäre wenn bei zeitintensiven Aufgaben die LongRunning Option der Task Klasse besser geeignet ist (also eigener thread statt threadpool). Bisher dachte ich es gäbe nur einen Nachteil im Bezug auf die Kontrolle über die Threads, wieso soll dann aber totzdem ein eigener Thread gestartet werden?

Habe den jetzt XMLWriter explizit auf UTF-8 gestellt.
Edit: Mir ist gerade aufgefallen, dass der Fehler sich in der gleichen Zeile befindet, nur die Position hat sich geändert. Nach dem Posten wurde mir ' ÿ ' auch richtig angezeigt (davor nur ' " '). Das Googeln ergab, dass 0xFF ÿ entspricht. Ich gehe davon aus das dieser in XML verboten ist? Wenn ja, wie könnte ich ihn herausfiltern?

verwendetes Datenbanksystem: <xml>
Hi,
ich arbeite an einem Program, welches eine Liste mit allen auf dem Computer vorhandenen Datein erstellt. Ein Index sieht ungefähr so aus:

<?xml version="1.0" encoding="utf-8"?>
<in:index formatVersion="1.0" xmlns:in="http://www.r3turnz.com/index">
  <entries hasPrefered="false">
    <other>
      <e n="">C:\</e>
      <e n="bootmgr">C:\bootmgr</e>
      <e n="BOOTNXT">C:\BOOTNXT</e>
      <e n="BOOTSECT">C:\BOOTSECT.BAK</e>
      <e n="hiberfil">C:\hiberfil.sys</e>
      <e n="pagefile">C:\pagefile.sys</e>
      <e n="swapfile">C:\swapfile.sys</e>
      <e n="$Recycle">C:\$Recycle.Bin</e>
      <e n="S-1-5-18">C:\$Recycle.Bin\S-1-5-18</e>
      ....

Der suchende Algorithmus funktioniert z.B. bei eingeschrenkten Datein (z.B. nur den Dokumente) einwandfrei. Wenn ich dies jetzt mit einem kompletten Index durchführe wird folgende Exception geworfen:> Fehlermeldung:

Ein Ausnahmefehler des Typs "System.Xml.XmlException" ist in System.Xml.dll aufgetreten.

Zusätzliche Informationen: Unerwartetes Token 'ÿ'. Erwartet wurde das Token '>'. Zeile 138, Position 58.

Die problematische Zeile wäre hier:

      <e n="bootmgr.exe">C:\Boot\pt-PT\bootmgr.exe.mui</e>

Hier liegt dann auch mein Problem. Das angeblich nicht erwartete Zeichen exestiert nicht.

Ich habe schon versucht einen "Filter" bei der Erstellung drüber laufen zu lassen, auch kein Erfolg:

        private static bool ContainsInvalidCharacters(string inString)
        {
            if (inString == null) return false;
            return inString.Any(ch => !XmlConvert.IsXmlChar(ch));
        }

Hallo,
ich habe mich ein wenig mit dem Garabge Collector beschäftigt. Obwohl der Garbage Collector meistens alles von alleine macht, würde ich gerne die sogenannten "dead objects" verstehen. Bei diesen wird dann ja der Finalizer aufgerufen, und danach der Speicher freigegeben. Aber wie erkennt der GC, dass es sich um ein totes Objekt handelt, oder ab wann ist ein Objekt für ihn "tot"?

Entschuldigt, aber ich bin immer noch nicht ganz durchgestiegen:

Referenztypen sind auch immer intialisiert - mit null.

heißt das:

string s; //ist das gleiche wie//
string s = null; 

Falls ja:Wieso wird beim einen ein Compilerfehler ausgelöst, beim anderen nicht?

Structs sind Wertetypen, die immer initalisiert sind.
Int hat dabei den Default Wert 0

heißt das:

int i; //entspricht//
int i = 0;

Auch an dieser Stelle wieder: Wieso beim ersten einen Compilerfehler?

Hoffe ich stehe nicht komplett auf dem Schlauch, danke für die Gedult.

Mir stellt sich hier noch eine letzte Frage:
Ich entnehme deiner Antwort Referneztypen und Wertetypen sind beide immer instanziert.(Mit null oder dem Standartwert) Meine Frage ist nun: Wieso wird bei einer lokalen Variablen, ein Compilerfehler ausgelöst? Im Debugger wird mir auch null bzw. der Standartwert angezeigt, genauso wie bei einem Klassenmember. (Diese wären dann ja schon instanziert)

Mit der Zeit vergisst man auch die Basics 😉
Deklarierter Referenztyp => Verweiß auf null
Wertetyp => Kein Verweiß sondern Wert im Stack (Muss Wert haben)

LG

Hallo,
angenommen man hat folgendes:

int i;
int z = i + m;

I wäre hier nicht instanziert und würde somit einen Compilerfehler auslösen.
Mir ist gerade aufgefallen, dass in folgendem Fall i initialisiert ist:

public class Myclass
{
private int _i;
public int I {get; set;}
public Myclass()
  {
  }
}

Wenn ich nun auf I zugreife ist die Variable initialisiert, obwohl im Konstruktor nichts definiert ist. Bisher habe ich in leeren Konstruktoren immer allen Feldern ihren Standartwert zugewiesen. Kann ich das also einfach lassen?

LG

Hallo,
ich möchte erzeugte Log Strings in einem Objekt sammeln.
(Genau genommen geht es um "Programm zum sicheren Starten und Loggen des Startvorgangs von Programmen". Hier wurde kritisiert, dass ich die erzeugten Log's einfach über den Rückgabewert sammle)
Ich habe mir ein bisschen Gedanken gemacht und mir ist folgendes Eingefallen:
-Die Referenz eines Objekt, z.B. LogBuilder, wird weitergereicht. Die Klasse stellt die Methode AddLine bereit.
->Eine Objekt könnte dem LogBuilder z.B. einfach null zuweisen
-Ein Interface schreibt ein Log-Event vor, welches abboniert wird.
->Das abbonierende Objekt müsste das Implemtierende kennen.
-Ein Interface schreibt eine String-Liste vor, welche dann einfach ausgelesen wird.
->Das implementierende Objekt müsste wieder bekannt sein.
->Wann wird die Collection ausgelesen?

->Mit den Interfaces hätte ich den Vorteil, dass ich sie einfach als "Log-Produzenten" interpretieren kann.

Das wäre was mir eingefallen ist. Was eigent sich da am Besten? Wenn ich daneben liege, wie löst man soetwas?

LG

@LaTino Nur aus Intresse: Deine Klasse implemntiert ein Interface IProgressable. Ich kann dazu nichts finden, also muss es von dir sein. Was für einen Sinn hat es.? Ich würde auf eine Art Fortschritsangabe tippen, aber du scheinst es nirgends zu verwenden.

Bei den 10 war mein Gedanke das von mindestens 10 (eher 100 oder 1000) Elementen auszugehen ist, und so nicht so oft das interne Array kopiert werden muss. Wahrscheinlich hätten es dann doch eher 100 oder 1000 seien müssen, und die Performance steigt wahrscheinlich auch nicht merklich...
Die Klassen habe ich wie bereits erwähnt von json2csharp, diese sind also generiert, ich wusste nicht das diese "qualitative" Nachteile haben.

An sich habe ich mir zu wenig Mühe mit der Deseralisierung gegeben, ich wollte mich da ehrlich gesagt nur schnell durch kommen, um eigentlich Anfangen zu können.

@LaTino Danke für den Code, werde ihn erstmal anschauen und dann für die Module und Stationen umschreiben. Ich würde bei den strings auf Enums setzen, sind ja alles auf einschränkbare Möglichkeiten bezieht.

Ich poste es jetzt hier, neuer Thread lohnt sich doch nicht:
Ich habe am Anfang probiert mit dem DataContractJsonSerializer zu Arbeiten, hier habe ich aber überhaupt nicht durchgeblickt... Naja hätte ich denn ersten Treffer der Suche besser gelesen, wäre ich früher auf Json.NET gestoßen, meine Methode sieht gerade so aus:

public class JsonLoader<T>
    {
        
        //Habe keinerlei Exception-Handling, 
        public List<T> Load(string jsonpath)
        {
            List<T> output = new List<T>(10);
            FileInfo jsonfileinfo = new FileInfo(jsonpath);
            if (!jsonfileinfo.Exists) return null;
            using (var jsonread = new JsonTextReader(jsonfileinfo.OpenText()))

            {
                var settings = new JsonSerializerSettings();
                settings.NullValueHandling = NullValueHandling.Include;
                JsonSerializer serializer = JsonSerializer.Create(settings);
                while(jsonread.Read())
                {
                 output.Add(serializer.Deserialize<T>(jsonread));
                }
            }
            return output;
        }
    } 
}

Die Klassen habe ich von json2csharp:

    public class ModuleGroup
        {
            public int id { get; set; }
            public int category_id { get; set; }
            public string name { get; set; }
            public string category { get; set; }
        }
   
        public class Module
        {
            public int id { get; set; }
            public int group_id { get; set; }
            public int @class { get; set; }
            public string rating { get; set; }
            public int? price { get; set; }
            public string weapon_mode { get; set; }
            public int? missile_type { get; set; }
            public string name { get; set; }
            public int? belongs_to { get; set; }
            public string ship { get; set; }
            public ModuleGroup group { get; set; }
            public double? mass { get; set; }
            public int? dps { get; set; }
            public double? power { get; set; }
            public int? damage { get; set; }
            public int? ammo { get; set; }
            public double? range_km { get; set; }
            public string efficiency { get; set; }
            public double? power_produced { get; set; }
          public int? duration { get; set; }
        public int? cells { get; set; }
        public string recharge_rating { get; set; }
        public int? capacity { get; set; }
       
        public int? count { get; set; }
       
        public int? range_ls { get; set; }
        
        public int? rate { get; set; }
        
        public int? bins { get; set; }
   
        public int? additional_armour { get; set; }
   
        public int? vehicle_count { get; set; }
        }
           public class System
        {
   
        public int id { get; set; }
      
        public string name { get; set; }
       
        public double x { get; set; }
      
        public double y { get; set; }
       
        public double z { get; set; }
      
        public string faction { get; set; }
       
        public long? population { get; set; }
       
        public string government { get; set; }
        
        public string allegiance { get; set; }
       
        public string state { get; set; }
        
        public string security { get; set; }
        
        public string primary_economy { get; set; }
      
        public string power { get; set; }
       
        public string power_state { get; set; }
      
        public int? needs_permit { get; set; }
        
        public int updated_at { get; set; }
        
        public string simbad_ref { get; set; }
        }
   
        public class Stations
        {
       
        public int id { get; set; }
       
        public string name { get; set; }
        public double x { get; set; }
      
        public double y { get; set; }
      
        public double z { get; set; }
        
        public string faction { get; set; }
        
        public long? population { get; set; }
        
        public string government { get; set; }
       
        public string allegiance { get; set; }
        
        public string state { get; set; }
        
        public string security { get; set; }
       
        public string primary_economy { get; set; }
       
        public string power { get; set; }
      
        public string power_state { get; set; }
       
        public int? needs_permit { get; set; }
       
        public int updated_at { get; set; }
       
        public string simbad_ref { get; set; }
        }

Nach einer gefühlten Ewigkeit wollte ich mein Code testen:

 static void Main()
        {
            JsonLoader<Elite_Dangerous_Tool.System> systemloader = new JsonLoader<Elite_Dangerous_Tool.System>();
            foreach(var loadedsystem in systemloader.Load("C:\\\\Users\\Name\\Desktop\\Elite Dangerous-Sternensystem\\systems.json"))
            {
                Console.WriteLine(loadedsystem.ToString());
            }
            Console.ReadKey();
        }

Es wird folgende Exception geschmießen:> Fehlermeldung:

Ein Ausnahmefehler des Typs "Newtonsoft.Json.JsonSerializationException" ist in Newtonsoft.Json.dll aufgetreten.

Zusätzliche Informationen: Cannot deserialize the current JSON array (e.g. [1,2,3]) into type 'Elite_Dangerous_Tool.System' because the type requires a JSON object (e.g. {"name":"value"}) to deserialize correctly.

To fix this error either change the JSON to a JSON object (e.g. {"name":"value"}) or change the deserialized type to an array or a type that implements a collection interface (e.g. ICollection, IList) like List<T> that can be deserialized from a JSON array. JsonArrayAttribute can also be added to the type to force it to deserialize from a JSON array.

Path '', line 1, position 1.

Wenn ich das richtig verstehe, weißt er mich darauf hin, er hätte ein Array gefunden, und ich solle doch bitte eine Collection in meiner Klasse hinzufügen. Ich kann aber beim besten willen weder in der Json noch in der Klasse eine Auflistung finden:

{"id":17,"name":"10 Ursae Majoris","x":0.03125,"y":34.90625,"z":-39.09375,"faction":"NoneNone","population":0,"government":"None","allegiance":"None","state":"None","security":"Low","primary_economy":"None","power":"None","power_state":null,"needs_permit":0,"updated_at":1455744292,"simbad_ref":"10 Ursae Majoris"

Ich habe es wirklich probiert zu lösen. Es scheint aber irgendwie ein Array zu geben was ich nicht finden kann...
Wahrscheinlich müsste ich mich in Json einarbeiten, ich will aber gerade einfach nur meine Objekte haben, um mit LinQ arbeiten zu können... Ich hoffe das ist verständlich.

LG

@LaTino Hört sich sehr intressant an, ich spiele nämlich Elite:Dangerous, aber konnte mich bisher nie fürs Handeln begeistern, weil mir einfach die Routen fehlen... So kann ich sie mir einfach berechnen lassen 😉
Habe aber noch eine Frage: Wie soll ich die Datein deseralisieren. Ich habe schon folgendes gefunden:
https://msdn.microsoft.com/de-de/library/bb908625%28v=vs.110%29.aspx
Ich brauche aber auch noch die Klassen dazu, ich kann ein paar Eigenschaften aus der Datei rauslesen, jedoch halt nicht alle...

LG

Hallo,
ich habe die Dokumentation nun nochmal gelesen, und mich auch schon mit den Musterdaten ausgetobt.
Jetzt wo eine längere Fahrt ansteht, würde ich LinQ gerne nochmal vertiefen, dazu bräuchte ich halt nur noch ein Projekt, in welchem ich LinQ gut einsetzen könnte. (Kann auch was sehr kleines sein)
Es würde sich halt leider auf LinQ to Objects beschränken, XML und der andere Kram kommt erst später...
Mir ist bewusst das es einen Sammelthread gibt, dort ist mir aber nichts zu diesem Thema ins Auge gefallen...

LG

Ich muss mich für den Post entschuldigen, hatte unüberlegt gehandelt.
Es kann natürlich auch nicht mein Ziel sein, dass du meinen Code schreibst (so lerne ich ja nichts), aber ehrlich gesagt ich wäre nie auf deine Vorschläge gekommen ):
Es ist wohl nochmal an der Zeit das Kapitel neuzulesen...
Ich werde erstmal versuchen den Code zu verstehen, nochmal nachlesen, und dann sehe ich weiter.

LG

@Abt Die Schicht-Architektur hatte ich in diesem Projekt schon implementiert. Da ich es schon länger nicht mehr angefasst habe, habe ich es glatt vergessen...

Ich hätte gerade keine Idee, wie ich diese Methode umsetzen soll 😉

@t0ms3n Daran habe ich auch schon gedacht:

 public List<Medium> GetEveryMediumOnce()
        {
            List<Medium> output = new List<Medium>();

            foreach (IGrouping<string, Medium> grouping in Mediums.GroupBy(p => p.Name))
            {
                if (grouping.Count() > 1)
                {
                }
                

            }
            return output;
}

@LaTino Ich kann mit Where nicht besonders viel anfangen, wie soll ich mit diesem Operator die Gleichtheit der Einträge in einer List filtern? 🤔
An sich stimme ich dir zu: Ich bin gerade mit diesem Versuch über sehr viele Probleme gestolpert, aber es kann ja nur besser werden 🙂

LG

Okay, der Versuch ist wohl daneben gegangen 😉

Hier meine "Testversion":

  var onlyOnce = _libary.GetEveryMediumOnce();
            var onlyOnceList = onlyOnce.ToList();
            if (onlyOnceList.Any() && !onlyOnceList.SequenceEqual(_libary.Mediums))
            {
                Console.WriteLine("Following Mediums will be deleted:");
                var intersect = _libary.Mediums.Intersect(onlyOnceList);
                var except = _libary.Mediums.Except(onlyOnceList);
                Console.WriteLine("Intersect:");
                foreach (var medium in intersect)
                {
                    Console.WriteLine(medium.ToString());
                }
                Console.WriteLine("Except:");
                foreach(var medium in except)
                {
                    Console.WriteLine(medium.ToString());
                }
                Console.Write("Do you really want to continue? Y/N");
                if (Console.ReadLine().ToLower() == "y")
                {
                    _libary.Mediums = new List<Medium>(onlyOnce);
                    Console.WriteLine("Deleted.");
                }
                else
                {
                    Console.WriteLine("Canceled.");
                }
            }
            else
            {
                Console.WriteLine("Didn't find any indentical mediums!");
            }

Zur Erklärung meiner Absicht: Ich will alle Dubletten haben, um anzuzeigen welche Medien gelöscht werden.
Die Except Methode hat aber das Problem, dass das Element ja auch in der zweiten Liste vorhanden ist, da es neben der Dublette auch noch den normalen Eintrag gibt.
Welche Methode würde den mein gewünschtes Ergebnis liefern?

Hallo,
ich bin nun ein gutes Stück in LinQ vorangekommen, und wollte nun neben meinen Programmen mit den Musterdaten auch etwas in ein "richtiges" Projekt implemtieren.
Dafür eignet sich meiner Meinung nach die Filmbibliothek sehr gut.
Ich wollte dafür mit den "einfacheren" Operatoren beginnen:
Distinct und Except
Hiermit filtere ich alle doppelten Medien heraus:

        public IEnumerable<Medium> GetEveryMediumOnce()
        {
            return Mediums.Distinct();
        }

     private void DeleteIdenticalMediums()
        {
            var onlyOnce = _libary.GetEveryMediumOnce();
            if (onlyOnce.Count() != 0 && onlyOnce != _libary.Mediums)
            {
                Console.WriteLine("Following Mediums will be deleted:");
                var except = _libary.Mediums.Except(onlyOnce);
                foreach (var medium in except)
                {
                    Console.WriteLine(medium.ToString());
                }
                Console.Write("Do you really want to continue? Y/N ");
                if (Console.ReadLine().ToLower() == "y")
                {
                    _libary.Mediums = new List<Medium>(onlyOnce);
                    Console.WriteLine("Deleted.");
                }
                else
                {
                    Console.WriteLine("Canceled.");
                }
            }
            else
            {
                Console.WriteLine("Didn't find any indentical mediums!");
            }
        } 

Aktuell liegt das Problem darin, dass zwar die identischen Medien richtig gefunden werden, aber der Except Operator keine Unterschiede findet...
Woran liegt das, soweit ich ihn verstanden habe, gibt er alle Einträge zurück, die in der Aüßeren, aber nicht in der Inneren vorhanden sind, also genau das was ich will...

LG

PS: LinQ bildet bei jedem Abrufen ja eine neue Ergebnismenge...In diesem Code verwende ich mehrmals dieselbe query (onlyOnce),kann aber garantieren, dass die Listen sich nicht ändern. Würde man hier in einer "statischen" Liste zwischen speichern, und ab dann, diese verwende.

Hallo,
Nur nochmal kurzes Verständniss, wöfür ist das Fragezeichen, ich habe erstmal an Nullable gedacht, das macht bei einem string aber wirklich keinen Sinn. (Und es müsste ja hinter den Typ und nicht hinter den Bezeichner)

LG

return value?.Substring( 0, Math.Min( value.Length, maxLength ) );

Hallo,
angenommen ich habe folgendes string.Format:

string.Format("{0,-15} {1}","zu langer Text aaaaaaaaaaaaaaa","a");

Aktuell wird einfach die Länge 15 übschritten und nach hinten verlägert. Ich möchte jedoch das abgeschnitten wird, also der Text auf keinen Fall länger als 15 ist.
Klar könnte ich auf Länge prüfen, und sonst den Substring nehmen. Gibt es aber eine "elegantere Methode",oder geht es nur so?

LG

Hallo,
ich wollte ini-File's nicht gut reden. Mir sind die stärken von XMl/Json durchaus bewusst 😉
Ich weiß auch das man sie normal in einem Editor öffnen kann, ein XML File, ist jedoch meiner Meinung nach ein wenig komplexer als ein ini-File.
Wenn ich jedoch darüber nachdenke wäre es aber auch gar nicht so schlimm.
Ich muss mier jedoch XML jedoch nochmal anschauen, blicke vorallem in XSD noch gar nicht durch.

LG

Hallo,
@Abt InI-Datein haben für mich den Vorteil, jeder könnte sie selber editieren (Brauche nicht wie z.B. bei XML ein Tool dafür zu entwerfen), und sie haben mir nihctmal 10 Minuten Einarbeitung gekostet 🙂 .
Aber keine Angst, mein aktueller "Schlachtplan" sieht so aus: LinQ, XML, WPF 8o . Bis ich da durchbin wird es zwar noch dauern, aber werde es schon packen.
@Papst Danke, ist behoben 😉
@MarsStein Okay, nur bringt es mir leider wenig ohne Verbesserungsvorschlag. 🤔

Nochmal danke an alle, fürs durchsehen.

LG

Hallo,
erstmal möchte ich den Sinn meines Programmes erläutern:
Einfach gesagt: Es startet ein Program.
Jedoch werden Fehlermeldungen in eine log-Datei geschrieben und Einstellungen werden aus einer ini-Datei geladen. Außerdem bietet es eine Unterstüzung zum verbinden von Netzlaufwerken und ermöglicht so das zentralen Speichern der log-Datein.
Zugegeben, das Einsazgebiet ist sehr klein, und aktuell ist es sehr viel Code um nichts, wenn man aber z.B. das Starten eines Programmes zur bestimmten Uhrzeit per Gui geplant werden könnte etc. wäre es effektiver, ich werde es deswegen später auch wahrscheinlich weiter entwickeln. (Gerade fehlt mir vorallem das Wissen in WPF).
An einigen Stellen bin ich mir mit den Variablen-Namen nicht schlüssig geworden, habe aber versucht es so gut wie möglich hinzubekommen.

Program.cs:

using System;
namespace Starter
{

    class Program
    {

        public static void Main()
        {
            Console.Title = "Starte...";
            string[] log = new string[2];
            ConfigLoader config = new ConfigLoader("config.ini");
            
                log[0] = config.Load() + "\n";
            if (config.LoadedStarter != null) log[1] = config.LoadedStarter.Start() + "\n";
                config.LoadedLogWriter.Write(log);
        }
    }
}

Config-Loader.cs:

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Reflection;
namespace Starter
{
    class ConfigLoader
    {
        public string ConfigPath { get; private set; }
        public ConfigLoader(string configpath)
        {
            ConfigPath = configpath;
            LoadedStarter = null;
            LoadedLogWriter = null;
        }
        public Starter LoadedStarter { get; private set; }
        public LogWriter LoadedLogWriter { get; private set; }
        private string programpath = null;
        string args = null;
        string[] splittedArgs = null;
        string logpath = null;
        string nas = null;
        string nasuser = null;
        string naspasswd = null;
        string naspath = null;
        public string Load()
        {

            if (File.Exists(ConfigPath))
            {
                IniFile config = new IniFile("config.ini");
                if (config.KeyExists("Programpfad", "Starter")) programpath = config.Read("Programpfad", "Starter").Trim();
                if (config.KeyExists("Aufzeichnungspfad", "Starter")) logpath = config.Read("Aufzeichnungspfad", "Starter").Trim();
                if (config.KeyExists("Argumente", "Starter")) args = config.Read("Argumente","Starter");
                if (config.KeyExists("Netzwerkpfad", "NAS") && config.KeyExists("Aufzeichnungspfad","NAS"))
                {
                    nas = config.Read("Netzwerkpfad", "NAS").Trim();
                    naspath = config.Read("Aufzeichnungspfad","NAS").Trim();
                    if (config.KeyExists("Benutzer") && config.KeyExists("Nas-Passwort") && logpath == null)
                    {
                        nasuser = config.Read("Benutzer", "NAS").Trim();
                        naspasswd = config.Read("Passwort", "NAS").Trim();
                    }
                }
            }
            return Create();
        }
        private string Create()
        {
            StringBuilder parambuilder = new StringBuilder("Folgende Paramter wurden geladen:\n");
            if (!string.IsNullOrEmpty(logpath))
            {
                LoadedLogWriter = new LogWriter(logpath);
                parambuilder.AppendFormat("Der Pfad für die Aufzeichnung wurde auf:{0} gesetzt.",logpath);
            }
             else
            {
                LoadedLogWriter = new LogWriter();
                parambuilder.AppendFormat("Es konnte kein Pfad für die Aufzeichnung gefunden werden! Standartwert:{0}.",LoadedLogWriter.DefaultDestination);
            }
            parambuilder.AppendLine();
            if(!string.IsNullOrEmpty(programpath) && splittedArgs != null && splittedArgs.Length > 0)
            {
                SplitArgs(args,new char[] { ',' });
                parambuilder.AppendFormat("Der Programpfad wurde auf:{0} gesetzt. Außerdem wurden folgender Argumente erkannt:{1}.",LoadedStarter.ExecutionPath,args);
            }
            else if(!string.IsNullOrEmpty(programpath))
            {
                LoadedStarter = new Starter(programpath);
                parambuilder.AppendFormat("Der Programpfad wurde auf:{0} gesetzt.",LoadedStarter.ExecutionPath);
            }
            else
            {
                parambuilder.AppendFormat("Es konnte kein Pfad zum Ausführen gefunden werden!");
            }
            if(!string.IsNullOrEmpty(nas) && !string.IsNullOrEmpty(naspath))
            {
                parambuilder.AppendLine();     
                parambuilder.Append("NAS-Konfiguration:");
                if (!string.IsNullOrEmpty(nasuser) && !string.IsNullOrEmpty(naspasswd))
                {
                   parambuilder.Append(LoadedLogWriter.Connect(nas,naspath,nasuser,naspasswd));
                }
                else
                {
                    parambuilder.Append(LoadedLogWriter.Connect(nas,naspath));
                }
            }
           
            return parambuilder.ToString();
        }
      
        private void SplitArgs(string args,char[] pattern)
        {
            splittedArgs = args.Trim().Split(pattern);
        }
    }

}

LogWriter.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Management.Automation;
using System.Collections.ObjectModel;
using System.Windows;
using System.Security;
using System.Text;

namespace Starter
{
    class LogWriter
    {
        public string Destination { get; set; }
        public string DefaultDestination
        {
            get
            {
                string appDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Starter");
                return Path.Combine(appDir, "log.txt");
            }
        }
        public LogWriter(string destination = null)
        {
            Destination = destination ?? DefaultDestination;
        }
        
        public void Write(string[] value)
        {
            string appDir = Path.GetDirectoryName(Destination);
            if (!Directory.Exists(appDir)) Directory.CreateDirectory(appDir);
            try
            {
                using (var fs = new FileStream(Destination, FileMode.OpenOrCreate, FileAccess.Write))
                {
                    fs.Seek(0,SeekOrigin.End);
                    using (var sw = new StreamWriter(fs,Encoding.UTF8))
                    {
                        sw.WriteLine("Starter v0.1 "+Environment.MachineName + " (" + DateTime.Now.ToString() + ")");
                        foreach(var towrite in value)
                        {
                            if(towrite != null)
                            sw.WriteLine(towrite);
                        }
          
                    }
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show(string.Format("Es ist ein Fehler wärend des Log-Schreibens nach:{0} aufgetreten:{1}",Destination,ex.Message),"CCleaner-Starter-Fehler",MessageBoxButton.OK,MessageBoxImage.Error);
            }
            
        }
        public string Connect(string root,string path, string user = null, string password = null)
        {
            var name = getNextDriveName();
            if (name == ' ') return "Kein weiteren Laufwerk-Bezeichner gefunden!";
            try
            { 
                using (var powershell = PowerShell.Create())
                {
                    powershell.AddCommand("New-PSDrive");
                    powershell.AddParameter("Name", name);
                    powershell.AddParameter("PSProvider", "FileSystem");
                    powershell.AddParameter("Root", root);
                    if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(password))
                    {
                        var secure = new SecureString();
                        foreach (char c in password)
                        {
                            secure.AppendChar(c);

                        }
                        PSCredential credential = new PSCredential(user, secure);
                        powershell.AddParameter("Credential",credential);
                    }
                    Collection<PSObject> powershellobjects =  powershell.Invoke();
                    if(powershell.HadErrors)
                    {
                        StringBuilder errorbuilder = new StringBuilder("Während des Verbindens mit dem Netzlaufwerk ist ein/mehrere Fehler aufgetreten:");
                        for(int i = 0; i < powershell.Streams.Error.Count; i++)
                        {
                            if (i < powershell.Streams.Error.Count - 1)
                            {
                                errorbuilder.Append(powershell.Streams.Error[i].ToString() + ",");
                            }
                         else
                            {
                                errorbuilder.Append(powershell.Streams.Error[i].ToString());
                            }
                        }
                        return errorbuilder.ToString();
                    }
                    else if(powershellobjects.Any())
                    {
                        PSDriveInfo psinfo = (PSDriveInfo)powershellobjects[0].BaseObject;
                        Destination = Path.Combine(psinfo.Root,path);
                       return string.Format("Netzlaufwerk erfolgreich geladen, log wird nun nach: {0} geschrieben!", Destination);
                    }
                    else
                    {
                      return "Ein unbekannter Fehler ist aufgetreten!";
                    }
                   
                }
            }
            catch(Exception ex)
            {
                return "Während des Verbindens mit dem Netzlaufwerk ist ein Fehler aufgetreten:"+ex.Message;
            }

            
        }
           
            
            
        private char getNextDriveName()
        {
            List<char> alphabet = new List<char>(26);
            for (char c = 'A'; c < 'Z'; c++)
            {
                alphabet.Add(c);
            }
            DriveInfo[] drives = DriveInfo.GetDrives();
            foreach(var drive in drives)
            {
                alphabet.Remove(char.Parse(drive.Name.Substring(0,1)) );
            }

            return alphabet.Any() ? alphabet[0] : ' ';
                
        }
    }
}

Starter.cs:

using System.IO;
using System.Diagnostics;
using System;
using System.Text;

namespace Starter
{
    class Starter
    {
        public string ExecutionPath { get; private set; }
        public string Arguments { get; set; }
        public string Start()
        {
            Process ccleaner = new Process();
            ccleaner.StartInfo.FileName = ExecutionPath;

            if(!string.IsNullOrEmpty(Arguments))  ccleaner.StartInfo.Arguments = Arguments;
                ccleaner.StartInfo.CreateNoWindow = true;
            
            try
            {
                ccleaner.Start();
            }
            catch (Exception ex)
            {
                return string.Format("Es ist ein Fehler während des Startens von: {0} aufgetreten:{1}.", ExecutionPath, ex.Message);
            }
            return string.Format("Erfolgreich:{0} gestartet!",ExecutionPath);
        }
        public Starter(string executionpath,string args = null)
        {
            ExecutionPath = executionpath;
            Arguments = args;
        }
    }

}

Die InI-File Klasse kommt von: http://stackoverflow.com/questions/217902/reading-writing-an-ini-file

LG

Es hat jetzt endlich geklappt 😃
Code:

     using (var powershell = PowerShell.Create())
                {
                    powershell.AddCommand("New-PSDrive");
                    powershell.AddParameter("Name", name);
                    powershell.AddParameter("PSProvider", "FileSystem");
                    powershell.AddParameter("Root", root);
                    if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(password))
                    {
                        var secure = new SecureString();
                        foreach (char c in password)
                        {
                            secure.AppendChar(c);
                        }
                        PSCredential credential = new PSCredential(user, secure);
                        powershell.AddParameter("Credential",credential);
                    }
                    Collection<PSObject> powershellobjects =  powershell.Invoke();
                    
                }

Hallo,
ich habe mir ein bisschen mehr Zeit gelassen:
Im verlinkten Thread bietet er 3 Möglichkeiten an.
1.Er fügt die Parameter über die AddParameter Methode ein, folgender Code:

powershell.Commands.AddCommand("Import-Module").AddParameter("Microsoft.Powershell.Managment");

                powershell.AddCommand(string.Format("NewPSDrive –Name “{0}” –PSProvider FileSystem –Root {1}", name, root));
                    Collection<PSObject> powershellobjects = powershell.Invoke();

Fehlermeldung:
Ein Ausnahmefehler des Typs "System.Management.Automation.CommandNotFoundException" ist in System.Management.Automation.dll aufgetreten.

Zusätzliche Informationen: Das Modul "NewPSDrive –Name “A” –PSProvider FileSystem –Root " konnte nicht geladen werden. Wenn Sie weitere Informationen wünschen, führen Sie "Import-Module NewPSDrive –Name “A” –PSProvider FileSystem –Root " aus.

An der Fehlermeldung sehe ich, das der erste Command scheinbar durchgelaufen ist das Modul aber immer noch nicht geladen ist.
Da der erste Kommand ja funktioniert hat, und dies offensichtlich ein Erfolg ist, wollte ich den zewiten genauso umgestalten.
Dabei kam folgender Code heraus:

 powershell.Commands.AddCommand("Import-Module").AddParameter("Microsoft.Powershell.Managment");

                powershell.AddCommand("New-PSDrive").AddArgument("Name \"" + name+"\"").AddArgument("PSProvider FileSystem").AddArgument("Root "+root);

Fehlermeldung:
Ein Ausnahmefehler des Typs "System.Management.Automation.ParameterBindingException" ist in System.Management.Automation.dll aufgetreten.

Schonmal eine andere Fehlermeldung, soweit ich den einen Satz in der Domumentation verstehe, das ich einen ungültigen Wert bei einem der Argumente Angegeben habe. Nach ein bisschen debuggen habe ich folgendes gefunden: Der Name also das eigentliche Argument scheint er nicht zu erkennen, und einfach alles in value zu schreiben. (Siehe Anhang) Die Exception scheinen daher zu kommen, da er die Escapesequenzen nicht erkennt und so plötzlich 4 \ vor dem root hat.
Ich habe es mit einem @ vor dem root versucht, jedoch wieder 4 .

Ich weiß nicht genau wie ich hier weiter machen soll, oder ob die \ überhaupt der Grund sind.
Die weiteren möglichkeiten habe ich gar nicht mehr probiert, da er den ersten Command jetzt zu schlucken scheint, hier erkennt er auch den Namen und den Wert des Parameters richtig.

LG

PS: Dies hier ist mehr ein "Live beim rumprobieren" dabeisein, so sieht man aber wenigstens wieso ich was gemacht habe.

Leider wieder Fehlanzeige:> Fehlermeldung:

Ein Ausnahmefehler des Typs "System.Management.Automation.CommandNotFoundException" ist in System.Management.Automation.dll aufgetreten.

Zusätzliche Informationen: Die Benennung "Import-Module Microsoft.PowerShell.Management" wurde nicht als Name eines Cmdlet, einer Funktion, einer Skriptdatei oder eines ausführbaren Programms erkannt. Überprüfen Sie die Schreibweise des Namens, oder ob der Pfad korrekt ist (sofern enthalten), und wiederholen Sie den Vorgang.

Er findet den Befehl nicht, obwohl er in Powershell direkt gefunden wird.
Hierbei habe ich jetzt das gleiche Problem wie der Typ im vochher verlinkten Thread, wie es aussieht haben die dort keine Lösung gefunden.
(https://social.msdn.microsoft.com/Forums/vstudio/en-US/7bcbfcba-7072-4757-8da7-bcb69de3d8fc/how-do-i-import-a-powershell-module-in-c?forum=csharpgeneral)
Werde nachher nochmal die dort gepostete RunScript Methode versuchen.

LG

Achso, habe auch den Baum auf der rechten Seite gar nicht geachtet, werde es gleich mal probieren...

Hallo,
habe die Hochkomma entfernt.
Ich verstehe ein Modul als einen Art dll die geladen wird.

Ich habe auch Windows 10 mit Power-Shell 5.0, wie gesagt ist das Modul auch einscheinend geladen wenn ich Powershell normal verwende. Es könnte sein, dass das Auto-Loading (Powershell soll Module wenn gebraucht automatisch importieren) nicht funktioniert, wenn Powershell selber nicht gestartet wurde..Um zu Laden muss ich wissen , welches Modul müsste ich den Laden, und wo dieses liegt.

LG

Hallo,
ich hatte im vorhinein schon debuggt, ein bisschen habe ich schon dazu gelernt 🙂

Das mit den Leerzeichen hatte ich selber nach dem letzten Post auch schon ausprobiert macht aber keinen Unterschied.
Außerdem ist root auch nicht null. (Siehe Anhang)

Mein Pi ist auf jeden Fall richtig konfiguriert, ich kann Datein übertragen etc. Er braucht normalerweise noch ein Passwort , dafür müsste er ihn aber erstmal finden 🤔

Über Powershell funktioniert es jetzt auch, wo er das Passwort herhat weiß ich nicht, hatte mich davor schoneinmal angemeldet, vieleicht daher?

Aus dem Code weiterhin folgende Fehlermeldung:> Fehlermeldung:

System.Management.Automation.dll aufgetreten.

Zusätzliche Informationen: Das Modul "New-PSDrive –Name “B” –PSProvider FileSystem –Root " " konnte nicht geladen werden. Wenn Sie weitere Informationen wünschen, führen Sie "Import-Module New-PSDrive –Name “B” –PSProvider FileSystem –Root " " aus.

Folgender Code läuft:

   
using (var powershell = PowerShell.Create())
                {
                    powershell.AddCommand(string.Format("New-PSDrive –Name “{0}” –PSProvider FileSystem –Root \" {1} \" ",name,root));
                    Collection<PSObject> powershellobjects = powershell.Invoke();
                    //Temporär um die möglichen Ausgaben zu finden.//
                   
                    foreach (var powershellobject in powershellobjects)
                    {
                        if (powershellobject != null)
                            Console.WriteLine(powershellobject.BaseObject.ToString());
                        Console.ReadKey();
                    }
                }

Ob ich bei root die Anführungszeichen habe, oder nicht macht keinen Unterschied.

LG

Hallo,> Fehlermeldung:

Ein Ausnahmefehler des Typs "System.Management.Automation.CommandNotFoundException" ist in System.Management.Automation.dll aufgetreten.

Zusätzliche Informationen: Das Modul "New - PSDrive –Name “A” –PSProvider FileSystem –Root “" konnte nicht geladen werden. Wenn Sie weitere Informationen wünschen, führen Sie "Import-Module New - PSDrive –Name “A” –PSProvider FileSystem –Root “" aus.

Dieser Fehler tit aus dem Code heraus auf.

Folgender bei gleichem Befehl in Powershell:> Fehlermeldung:

New-PSDrive : Der angegebene Laufwerkstamm "\192.168.1.46\Rasp" ist entweder nicht vorhanden, oder es handelt sich
nicht um einen Ordner.
In Zeile:1 Zeichen:1

• New-PSDrive –Name “A” –PSProvider FileSystem –Root “\192.168.1.46\Ra ...

•   + CategoryInfo          : ReadError: (A:PSDriveInfo) [New-PSDrive], IOException  
    + FullyQualifiedErrorId : DriveRootError,Microsoft.PowerShell.Commands.NewPSDriveCommand
  

Ich kann die Freigabe über den Windows Explorer ganz normal abrufen.

Habe jetzt auch die Arraylist weg:

 List<char> alphabet = new List<char>();
            for (char c = 'A'; c < 'Z'; c++)
            {
                alphabet.Add(c);
            }
            DriveInfo[] drives = DriveInfo.GetDrives();
            foreach(var drive in drives)
            {
                alphabet.Remove(char.Parse(drive.Name.Substring(0,1)) );
            }

            return alphabet.Any() ? alphabet[0] : ' ';

Das mit der Version war mein Fehler, neben einer exe in Version 1.0 gibt es auch noch eine ohne Versionsangabe, wahrscheinlich dann 5.0.

LG

Hey,
das nomale Powershell schluckt den Befehl, in meinem Fall würde der so aussehen:

New-PSDrive –Name “K” –PSProvider FileSystem –Root “\\192.168.1.46\Rasp” –Persist

Hier meint Powershell der Typ der Netzwerkresource wäre falsch.> Fehlermeldung:

New-PSDrive : Der Typ der Netzwerkressource ist falsch
In Zeile:1 Zeichen:1

• New-PSDrive –Name “K” –PSProvider FileSystem –Root “\192.168.1.46\Ra ...

•   + CategoryInfo          : InvalidOperation: (K:PSDriveInfo) [New-PSDrive], Win32Exception  
    + FullyQualifiedErrorId : CouldNotMapNetworkDrive,Microsoft.PowerShell.Commands.NewPSDriveCommand
  

Mir ist gerade aufgefallen das ich nur Powershell 1.0 installiert habe, irgendwo meine ich gelesen habe, das erst mit Powershell 2.0 die KLasse verwendet werden kann.

Wenn ich Powershell nachinstallieren möchte gibt es nur Versionen für WIndows 7, diese funktionieren bei mir auch nicht.

LG

PS:Der Thread zieht sich immer mehr weg von der eigentlichen Freigabe und gehört jetzt schon fast mehr in Infrastruktur 😃 Wie geht man damit um?

Hey,
okay ich bin nun ein gutes Stück weiter:

        public bool Connect(string root, string user, string password)
        {
            var name = getNextDriveName();
            if (name == ' ') return false;
            try
            {
                
                using (var powershell = PowerShell.Create())
                {
                    powershell.AddCommand(string.Format("New - PSDrive –Name “{0}” –PSProvider FileSystem –Root “{1}”",name + ":\\",root), true);
                    Collection<PSObject> powershellobjects = powershell.Invoke();
                    //Temporär um die möglichen Ausgaben zu finden.//

                    foreach (var powershellobject in powershellobjects)
                    {
                        if (powershellobject != null)
                            Console.WriteLine(powershellobject.BaseObject.ToString());
                        Console.ReadKey();
                    }
                }
            }
           catch
            {
                return false;
            }
            return true;
        }
           
            
            
        private char getNextDriveName()
        {
            //Ich finde die Konvertierung hier nicht schön, brauche aber die Remove Methode, wenn ich das Element löschen möchte. 
            char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
            ArrayList alphabet =  ArrayList.Adapter(alpha);
            DriveInfo[] drives = DriveInfo.GetDrives();
            foreach(var drive in drives)
            {
                alphabet.Remove(char.Parse(drive.Name.Substring(0, 1)));
            }

            return alphabet.Length > 0 ? (char)alphabet[0] : ' ';
                
        }

Das Problem ist es wirde eine Exception geschmissen, mein Command würde nicht exestieren, wie muss es richtig angeben?

LG

Hallo,
ich scheitere gerade noch an der Umsetzung. Ich möchte System.Management.Automation importieren, jedoch exestiert sie nicht bei mir, (Siehe Anhang) Wahrscheinlich hab ich irgendwas übersehen. 😁
Da ich komplet wenig zu einer Powershell in C# finden kann, außerdem dem msdn Eintrag, wollte ich noch wissen, wie ich an den "Output" komme, ich habe einen HasErrors Member gefunden, soll ich einfach so überprüfen?

LG

Hallo,
ich möchte mich innerhalb meines Programmes mit einer Netzwerk-Freigabe verbinden, ich habe folgendes Snippet gefunden:

        /// <summary>
        /// Disconnects a network drive
        /// </summary>
        /// <param name="drive">Drive (z.B. L:)</param>
        private void MapNetworkDriveDisconnect(string drive)
        {
            Process p = new Process();
            p.StartInfo.FileName = "net";
            p.StartInfo.Arguments = string.Format("use {0} /DELETE", drive);
            p.StartInfo.UseShellExecute = false;
            p.Start();
        }
        /// <summary>
        /// Connects a network drive
        /// </summary>
        /// <param name="drive">The drive letter (e.g. L:)</param>
        /// <param name="server">The UNC path to the remote drive (e.g. \\MyServer\MyPrinter)</param>
        /// <param name="user">The User</param>
        /// <param name="password">The Password Used For Login</param>
        private void MapNetworkDriveConnect(string drive, string server, string user, string password)
        {
            Process p = new Process();
            p.StartInfo.FileName = "net";
            p.StartInfo.Arguments = string.Format("use {0} {1} /user:{2} {3}", drive, server, user, password);
            p.StartInfo.UseShellExecute = false;
            p.Start();
        }

(von http://dotnet-snippets.de/snippet/netzlaufwerke-verbinden-trennen-mit-user-u-passwort/1429)
Meine jetzige Planung sieht so aus:
Ich brauche einen Laufwerknamen, dazu brauche ich ein Alphabet, wie stelle man das am besten an? Den Rest zum nächsten freien Laufwerk-Namen habe ich schon.

Wie man oben erkennt startet er einen Prozess, wie kann ich hier das Ergebnis abfragen, also ob die Verbindung erfolgreich war?

LG

Hallo,
ich habe diese so verstanden:
Kovarianz: Stat dem angegebenen Rückgabe kann auch ein abgeleiteter Typ verwendet werden.
Kontravarianz: Das gleiche mit Parametern.

Es erninnert mich sehr stark an Polymorphie, wo liegt der Unterschied?
Für welche Typen gibt es den Kovarianz und Kontravarianz?

Bei generischen Typen muss anscheinend in und out angegeben werde, je nachdem ob Rückgabewert oder Parameter. Wieso dies?

LG

Hallo,
ich wollte hier meine Klassen zum Bereitstellen einer Auzug-Logik überprüfen lassen,mir ist bewusst das Logic() und ein eigener Thread fehlt.
Als Frage würde ich direkt fragen: Wenn in einem Auftrag(Task), das Event nicht abonniert wurde,wird eine Exception geschmissen. Ich möchte diese eigentlich zum verwender der Klasse durchreiche, muss sie aber eigentlich auch abfangen um das entsprechende Element aus der Task Liste zu entfernen. Wie soll ich das lösen, mit weiteren Events?

Hier der Code:
Elevator.cs

C#-Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace ElevatorCore
{


    public class Elevator
    {

        #region Events
        #endregion
        #region Properties
        private int _currentFloor;
        public int CurrentFloor { get; }
        public int MaxFloor { get; }
        public int MinFloor { get; }
        private List<ElevatorTask> _tasks = new List<ElevatorTask>();

        //Nur Verübergehend, wenn ich genug über Multithreading, wird ein Thread im Konstuktor gestartet...//
        private List<ElevatorTask> Tasks
        {
            get
            {
                return _tasks;
            }
            set
            {
                _tasks = value;
                Logic();
            }
        }
        #endregion
        #region Constructors
        public Elevator(int maxFloor,int minFloor)
        {
            this.MaxFloor = maxFloor;
            this.MinFloor = minFloor;
            this.CurrentFloor = MinFloor;
        }
        #endregion
        #region PublicMethods
        public bool NewCustomer(ElevatorTask task)
        {

            if (task != null && task.ArriveEventIsInitialized)
            {
                _tasks.Add(task);
                return true;
            }
            return false;
        }
        #endregion
        #region PrivateMethods

        private void Logic()
        {
            while(Tasks.Any())
            {

            }
        }
        private bool Move(int value)
        {
            if(FloorIsAvaible(value))
            {
               _currentFloor = (CurrentFloor + value);
                return true;
            }
            return false;
        }
        private bool FloorIsAvaible(int value)
        {
            if (value >= MinFloor && value <= MaxFloor && value != CurrentFloor) return true;
            return false;
        }
        private ElevatorTask GetNearestRequested()
        {
            if (Tasks.Count == 1) return Tasks[0];
            else if (Tasks.Count < 1)
            {
                Tasks.Sort(new ElevatorLevelComparer());
                return Tasks[0];
            }
            else
                throw new InvalidOperationException("No Task found!");

        }
        private ElevatorTask GetNearestInputed()
        {
            if (Tasks.Count == 1) return Tasks[0];
            else if (Tasks.Count < 1)
            {
                Tasks.Sort(new ElevatorInputComparer());
                return Tasks[0];
            }
            else throw new InvalidOperationException("No Task found");
        }
        #endregion
    }
}

ElevatorTask.cs:

C#-Code:

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

namespace ElevatorCore
{
    public struct ElevatorTask : IEquatable<ElevatorTask>
    {
        #region Operators
        public static bool operator == (ElevatorTask task1, ElevatorTask task2)
        {
            if ( ((object)task1 == null ) || (object)task2 == null ) return Object.Equals(task1, task2);
            return task1.Equals(task2);
        }
        public static bool operator != (ElevatorTask task1,ElevatorTask task2)
        {
            return ! task1.Equals(task2);
        }
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            if (obj is ElevatorTask) return Equals((ElevatorTask)obj);
            return false;
        }
        public bool Equals (ElevatorTask task)
        {
            if ((object)task == null) return false;
            if (this.RequestedFloor != task.RequestedFloor) return false;
            if (this.InputedFloor != task.RequestedFloor) return false;
            return true;
        }
        #endregion
        #region Events
        public event EventHandler<ElevatorArriveEventArgs> ElevatorArrive;
        private void OnElevatorArrive(ElevatorArriveEventArgs args)
        {
            if (ElevatorArrive != null) ElevatorArrive(this, args);
            else throw new InvalidOperationException("Elevator-arrive event not initialized! ");
        }
        #endregion
        #region Methods
        public override int GetHashCode()
        {
           return TaskID.GetHashCode();
        }
        #endregion
        #region Properties
        public int RequestedFloor { get; set; }
        private bool _arrivedAtRequestedFloor;
        public bool ArrivedAtRequestedFloor
        {
            get
            {
                return _arrivedAtRequestedFloor;
            }
            set
            {
                _arrivedAtRequestedFloor = value;
                if (value == true) OnElevatorArrive(new ElevatorArriveEventArgs(RequestedFloor));
            }

        }
        public string TaskID { get; }
        public bool ArriveEventIsInitialized
        {
            get
            {
                return ElevatorArrive != null ? true : false;
            }
        }
        public int? InputedFloor { get; set; }
        #endregion
        #region Constructors
        public ElevatorTask(int requestedFloor,string taskID)
        {
            RequestedFloor = requestedFloor;
            _arrivedAtRequestedFloor = false;
            InputedFloor = null;
            ElevatorArrive = null;
            TaskID = taskID;
        }
        #endregion
    }
}

ElevatorLevelComparer.cs:

C#-Code:

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

namespace ElevatorCore
{
    class ElevatorLevelComparer : IComparer<ElevatorTask>
    {
        public int Compare(ElevatorTask x, ElevatorTask y)
        {
            //null
            if (x == null && y == null) return 0;
            else if (x == null) return -1;
            else if (y == null) return 1;

            //Comparison
            return x.RequestedFloor.CompareTo(y.RequestedFloor);
        }
    }
}

ElevatorInputComparer.cs:

C#-Code:

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

namespace ElevatorCore
{
    class ElevatorInputComparer : IComparer<ElevatorTask>
    {
        public int Compare(ElevatorTask x, ElevatorTask y)
        {
            //null
            if (x == null && y == null) return 0;
            else if (x == null) return -1;
            else if (y == null) return 1;
            //Input null
            if (x.InputedFloor == null && y.InputedFloor == null) return 0;
            else if (x.InputedFloor == null) return -1;
            else if (y.InputedFloor == null) return 1;
            //Comparison
            return x.InputedFloor.Value.CompareTo(y.InputedFloor.Value);
        }
    }
}

LG

Hallo,
der Fehler lag die ganze Zeit bei mir 😃 Sorry...
Habe gar nicht an die Parse Methode gedacht, und mich nur auf den Konstruktor versteift...

LG

Hallo,
ich hatte meine Frage anders gemeint:
Ich bekomme per Konsolen Argument eines string, und diesen muss ich in ein byte Array umwandeln, der erste Schritt war für mich die Konvertierung in ein char Array. (mit toCharArray()). Nun ist die Frage wie bekomme ich dieses Array in ein Byte Array konvertiert?
Das eben nicht 56 sondern die übergebene 8 in einem byte Array zurückgegeben wird.
Mit dem byte Array werde ich den eine IP Addresse erstellen...
@Abt Wie genau würde ich das entfernen von allen Punkten aus einem string bewerkstellen? Habe an string.replace gedacht, dies würde aber kein Sinn machen, da ich ja nicht ersetzen sonder entfernenwill.string.remove will kein pattern, sonder einen Index?Welche Methode ist dafür gedacht?
LG

Hallo,
ich habe ein Programm, in welchem eine IP-Adresse per Konsolen Argument übergeben wird. Ich hatte zwei Probleme, ich brauche ein byte Array zur konstruktion eines IP-Adressen Objekts und ich musste die Punkte aus dem string bekommen.

Das zweite habe ich einfach gelöst, indem bei der Eingabe auf die Punkte verzichtet wird, also stat:
1.1.1.1 1111

Die Konvertierung in ein byte Array gestaltet sich schwieriger. Wenn ich expleziet ein char in einen byte konvertiere wird statt der übergebenen 8 56 zurückgegeben.

Könnte dies an der Kodierung des Strings liegen? Also 8 ist 56 ?

Ich möchte aber den übergebenen Wert nur als byte zurück. Wie funktioniert das?

LG