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

Durch die Queue wird aber deine Überprüfungslogik, ob du es machen darfst überflüssig ...
Solange es drin ist, darfst du es einfach übersetzen.

Ähm - doch doch machen sollst du sie schon, aber du nimmst sie aus einer Liste heraus, übersetzt sie und legst sie danach in der "schon abgearbeitet" Liste ab, etwa:

public List<WhateverObject> TranslateAll() {
  Queue<WhateverObject> originals;
  List<WhateverObject> results;

  //Originials füllen

  while(originals.Size > 0)
  {
    var current = originals.Pop();
    TranslateObject(current);
    results.Add(current);
  }

  return results;
}

Ich vermute, du kannst das erreichen indem du die ProcessStartInfo mit einer solchen URL fütterst und ShellExecute auf true stellst.

Wenn ich das richtig verstehe willst du keine Doppelübersetzung.

5 -> 55: Okay
22 -> 5: Okay

22 -> 5 -> 55: BadCase

Abgessehen von der Topologischen Sortierung kannst du auch einfach zwei Listen machen:

Liste1: Nicht übersetzte Objekte (Queue erscheint geeignet, weil es Pop() gibt)
Liste2: Übersetze Objekte

Damit vermeidest du die doppelte Übersetzung.

Wenn ich nur mal rate, würde ich sagen, du machst das was wir da sehen in AddUser (das bringt so nix, denn du machst es auf eine NEUEN Form1, die du niemals anzeigst)

Richtig wäre also in Form1 sowas wie:

//..
Form AddUser = new AddUser();
AddUser.FormClosed += AddUserFormClosed;
AddUser.Show();
//..

private void AddUserFormClosed(object sender, FormClosedEventArgs args) {
  FillTree();
}

Wenn du uns zeigst, wie du das Form_Closed Event abbonierst, können wir dir bestimmt weiterhelfen.

Du musst eine Topologie (für eine topologische Sortierung) aufbauen.
Im Endeffekt musst du also die Übersetzungen als Pfade und die Werte als Knoten in einem Graph verstehen. Da dein Pfad (bzw. Graph) gerichtet ist, kannst du ein Ende und einen Anfang ausmachen.
Wenn du nun von Ende bis Anfang sortierst, dann hast du dein Ergebnis.

Dazu auch in der Wikipedia: Tolopogische Sortierung (EN)

Sharepoint kann sowas.
WebDAV nur beschränkt, denn WebDAV macht im Prinzip nen Download und nen Lock (bzw. Excel macht das so)

Ah - das ist auch ne gute Idee - ich habe eben versucht das ganze über ein CacheMiss Event zu regeln. Damit laufe ich aber gefahr, dass mehrere Instanzen die den Cache nutzen das Objekt versuchen zu setzen.

Vielen Dank

Vielleicht versteh ich was nicht, aber wenn ich ein Element hinzufügen will - dann habe ich es offensichtlich schon - warum sollte ich dann ein vorhandenes aus dem Cache nehmen?

Aber das hängt wohl indirekt mit dem Callback zusammen, den ich noch nicht gefunden habe ...

Hallo allerseits,

ich versuche grade ein paar Daten in einem System.Runtime.Caching.MemoryCache abzulegen.
Dabei bin ich über folgende Fragestellung gestolpert:

Wenn ich einen Cache-Miss habe - gibt es die Möglichkeit einen Callback (zu registrieren (beispielsweise einen der auf dem Key operiert), der automatisch aufgerufen wird, oder muss ich das "per Hand" machen?

Und welchen Sinn macht eigentlich die AddOrGetExisting-Funktion?

Gruß

Vielleicht kannst du ein OCR benutzen und auf den "eingemalten" Text loslassen.
Es gibt dort bestimmt verschiedene Schnittstellen dafür (die sind aber tendenziell nicht kostenfrei z.B. Abbyy)

Ein Einzelnes Enum wird deine Anforderung nicht erfüllen können, aber du kannst ein Enum definieren und anschließen (statische) Zugriffsklassen/Properties definieren, wie zum Beispiel:

namespace MimeType {
  enum MimeTypes {
    // ...
  }

  public static class Audio {
    public static MimeTypes MPEG { get { return MimeTypes.AudioMPEG; } }
    public static MimeTypes WAV { get { return MimeTypes.AudioWAV; } }
  }
}

Ich weiß nun nicht, ob der Client schon fest definiert ist, aber ich kann dir zumindest sagen, wie der SQL-Server das Regelt:

Und zwar hat jede Meldung eine Nummer - hinter den Nummern versteckt sich eine Einfacher Format-String und dann wird der Formatstring ausgewertet und die {0} werden ersetzt durch die übergebenen Parameter.

Genau das kannst du auch tun.
Übermittle die Nachricht als Formatstring (oder nur eine NAchrichtennummer) und den variablen Inhalt als array oder Liste.
Dann kannst du einfach die gesamte Meldung erzeugen und außerdem Feststellen, ob du die Meldung schon kennst und referenzieren kannst.

Das kannst du mit einem enstprechenden "ValueConverter" erreichen. Zum Beispiel kannst du den Status in eine Farbe übersetzen (sogar bidirektional)

Hier ein (sehr eingeschränktes, quick'n'dirty) Beispiel:

class StringEmptyToVisibilityConverter : System.Windows.Markup.MarkupExtension, IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            var s = value as string;
            return string.IsNullOrEmpty(s) ? Visibility.Collapsed : Visibility.Visible;
        }
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            return null;
        }

        private static StringEmptyToVisibilityConverter _instance;
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            return _instance ?? (_instance = new StringEmptyToVisibilityConverter());
        }
    }

Ich glaube das geht nicht, und der Antwortende in diesem Thread glaubt das ebenfalls nicht: Stackoverflow - Get error and standard output from an elevated child process

Wenn es deine eigene Assembly ist, kannst du ihr einen Starken Namen verpassen, indem du sie beim Kompilieren auch gleich Signierst - das kannst in den Projekteinstellungen setzen.
Dazu brauchst du eine Signatur, die du dir mit sn.exe erstellen kannst.

Ich glaube das Grid und eventuell die Liste von Infragristics können so etwas

Was wäre denn in so einem Fall die ToolStripDropDownCloseReason?

AppFocusChange?

401 heißt, dass du nicht Authentifiziert bist - dabei geht es nicht um das PHP Skript, sondern um den Aufrufenden Benutzer (also derjenige der den Webbrowser öffnet).
Der hat nämlich keinen Zugriff auf die Resource, die du dort haben willst.

Auch wenn ich mich wiederholen sollte:
Solche Fehler sieht man, wenn man den Fiddler oder ähnliche Tools verwendet.

Ich würde Vermuten, dass die Fehlermeldung genau zutrifft (nämlich falsches PW/Username)

Wie ermittelst du denn Passwort und Benutzername?

//Um die Frage genauer zu gestalten:
Nutzt du Kerberos/NTLM, Digest, Basic?
Ist das Hardcodiert?

Verarbeitet dein Netzwerk WOL überhaupt korrekt?

Hallo Insider,

du benutzt einfach den ServiceClient (bzw. Proxy), und rufst die Asynchrone Methode auf. Vorher abonnierst du das completet event und dort erhälst du in den Event Arguments alle nötigen Informationen.

Danke für deine Antwort, aber das war es nicht - es hat eine Weile gedauert, bis ich begriffen habe, was da eigentlich passiert.

In PowerShell erzeugt

@{"SomeName"="SomeValue"}

var myValue = new System.Collections.HashTable {{ "Add", smptAddress }};
command.parameters.Add("EmailAddresses", myValue);

Ich habe ein Problem beim übergeben eines Parameters via Powershell.
Es handelt sich um das Exchange2010 PS-Addin und ich versuche eine Emailadresse (Alias) hinzuzufügen:

using (var pipeline = ExchangeManagementShell.CreatePipeline())
            {
                var command = new Command("Set-Mailbox");
                command.Parameters.Add(IdentityParameter, username);
                //property = "EmailAddresses"
                //value = "@{Add='neuesAlias@example.com'}"
                command.Parameters.Add(property, value);

                pipeline.Commands.Add(command);

                pipeline.Invoke();
                if(pipeline.Error != null && pipeline.Error.Count > 0)
                    throw new ApplicationFailedException(pipeline.Error.Peek().ToString());
            }

Set-Mailbox grumbler85 -EmailAddresses @{Add='neuesAlias@example.com'}

Zum Stream gehört eine Position. Das ist ein Zeiger, wo du grade im Stream liest. Wenn du stream.Read ausführst, wird AB dieser Position gelesen.
Mit Seek(0, Begin) kannst du diese Position auf 0 zurücksetzen und somit liest du wieder den ganzen Stream.
Ähnlich wie bei einer Kasette könnte man sagen (nur ohne umdrehen).

Eventuell musst du deinen Stream "zurückspulen"

stream.Seek(0, SeekOrigin.Begin);

Ich würde tippen der "offizielle Ansatz" heißt "reboot for Software-Maintenance"

Wie dem auch sei - falls du zwei Server hast, die in einem Load-Balance Verbund stehen kannst du auch einen entfernen, dort updaten, dann den LoadBalancer auf den Upgedatetn umschalten und selbiges das Update auf dem anderen Server machen - das wäre wohl ne ganz saubere lösung.

Oder du gibst den usern in zukunft einen Link und installierst in verschiedene Verzeichnisse, dann musst du nur den Link ändern (was leider bei den Freigabe-Leuten schwer wird).

Schnelle und recht saubere Lösung per Skript:
Alle Verbindungen schließen (also TS-Sitzungen und SMB-Sitzungen), Software austauschen, Verbindungen wieder erlauben. Das ganze ankündigen und Nachts laufen lassen.

Die Klasse "Ping" gibt es seit .NET 2.0 und ist in 4.0 immer noch vorhanden.
Du findest sie in intantiierst sie so:

var p = new System.Net.NetworkInformation.Ping();