Richtig, die Dev Fabric des SDKs kann nicht auf XP installiert werden. Die brauchst du allerdings nur wenn du irgendwelche Roles lokal simulieren/testen möchtest. Falls nur Blob- oder Table-Storage verwendet wird braucht man die Dev Fabric nicht wirklich, da es sich ohnehin lohnt gegen echte Azure storage accounts zu testen.

In der Praxis braucht man dafür nur die folgende Assembly des SDKs zu referenzieren:

Microsoft.WindowsAzure.StorageClient.dll

Dies funktioniert auf XP genau so gut wie auf Win7, d.h. nicht nur sind die entwickelten Anwendungen auch auf XP lauffähig sondern es kann auch auf XP entwickelt werden. Hast du Zugriff auf diese Assembly, oder lässt sich das SDK gar nicht erst installieren?

Andere Toolkits: Da gibt es z.B. Lokad.Cloud, das allerdings wiederum auf dem offiziellen StorageClient aufbaut (Disclamer: bin da beteiligt)

Es gibt nicht nur eine REST Api sondern auch ein fertiges SDK von Microsoft, daneben auch Toolkits von anderen Anbietern die darauf aufbauen.

(Ich arbeite täglich mit Azure)

Ja, man kann die Anzahl Instanzen auch im Betrieb ändern, das initialisieren zusätzlicher Instanzen (parallel falls nur eine Upgrade Domain) dauert in der Praxis aber durchaus mal 5 Minuten.

Ein Beispiels eines managed codec findest du hier (2, 3). Es wird allerdings nicht irgend ein avi Film decodiert, sondern die Video-Stream Ausgabe eines C64 Emulators generiert (als Video Codec). Ist allerdings Silverlight 3, auf Basis der MediaStreamSource Klasse ...

Falls diesen Thread wieder mal jemand findet, ein interessanter Artikel über die Innereien der .Net regular expressions (auch zum Thema Compilation): How .NET Regular Expressions Really Work

(PS: Der Palladium Prototyp (der Link von oben) ist speziell aufgebaut weil er direkt mit Linq Expressions arbeitet und die ganze Baumstruktur entsprechend nicht beeinflussen kann/will. Ist also wahrscheinlich eine komplett andere Architektur als bei dir und kaum übertragbar...)

Die Addition mit den Operatoren würde ich jedenfalls in der Term-Klasse definieren, das hat sich bewährt. Aber sie muss gar nicht abstrakt sein, denn das einzige was sie machen wird ist eine neue Instanz deiner Add-Klasse erstellen und zurückgeben, also

Term1 + Term2 => Sum(Term1,Term2)

Außerdem möchte ich nicht in der Implementation alles mit "if(typeof(rhs)==whatever)"
vollschreiben müssen. Wäre auch nicht das richtige, oder?

Wenn du die Term Klasse mit abstrakten oder virtuellen Methoden wie Calculate, Expand, Simplify, Derive, etc. erweiterst und die entsprechenden Klassen wie Sum das selber machen lässt brauchst du erfahrungsgemäss nur sehr wenige solche Abfragen.

Vielleicht sollte nur die Klasse Sum wissen, wie man andere Objekte miteinander Addiert - dann müsste diese nach allen Typen differenzieren, bzw. den Operator für alle Typen überladen.

Ja, nur Sum sollte wissen wie addieren funktioniert, aber das heisst nicht dass Term nicht wissen darf dass es eine Addition gibt.

Tip: beschränke dich auf nur wenige skalare Datentypen (z.b. double), macht alles sehr viel einfacher.

Habe in C# übrigens schon diverse kleine computer algebra systeme geschrieben, der neuste Ansatz arbeitet direkt mit rohen Linq Expressions...

Also etwas wie CC by-nc, bzw. juristen-version? Oder allenfalls auch CC by-nc-nd.

Eine Opensource Lizenz kannst du nicht verwenden, da du ja kommerzielle Verwendung verbieten möchtest, was nach meinem Verständnis (IANAL) prinzipiell der Opensource Definition (gem. OSI) wiederspricht.

Könnte sich vielleicht jemand mal ein zwei Originale von Microsoft anschauen und mir sagen, wie es darin ausschaut? Ich hab es bis jetzt nämlich noch nicht hinbekommen, mir den original source anzuschauen.

Ich habe bis vor kurzem in einem Microsoft Entwicklungszentrum gearbeitet (Neue App im Office/UC Bereich auf WPF Basis), dort hatten wir durchgehend "m_" (bzw. "s_" für static, "c_" für const) verwendet. War aber natürlich ein komplett anderes Team als das des Frameworks. Und ja, praktisch alle im Team hatten C++ "Erfahrung"...

Hallo,

Mir ist gerade aufgefallen dass ich hier mein Math.NET Projekt noch gar nicht vorestellt habe.
Gestern konnte ich eine neue Version von Math.NET Iridium (der Numerik-Teil des Projekts) freigeben:

Math.NET Iridium herunterladen (Quelltext und Binaries)

Eine Auflistung der Änderung gibt es jeweils auf der verlinkten Seite oder direkt im Tracker.

Lizenz: LGPL, kann somit auch in closed-source Projekten eingesetzt werden (nur Änderungen an der Bibliothek selber müssen offen gelegt werden).

Rückmeldungen und Anregungen nehme ich gerne überall entgegen, für Vorschläge aber am besten via UserVoice, ansonsten hier oder in unserem eigenen Forum. Auch jede andere Mithilfe ist natürlich willkommen.

Wenn eine Methode ein Objekt gleichen Typs zurückgibt, dann nehme ich an dass der Methodenaufruf keine Nebenwirkungen hat, also die ursprüngliche Instanz nicht geändert wurde (sondern die Änderungen in der zurückgegebenen Kopie reflektiert werden).

Die string-Methoden geben das Resultat zurück weil String (so-gut-wie) immutable ist, die Methoden haben entsprechend auch keine Nebenwirkungen.

Meiner Meinung nach sollte dieses Fluent-Pattern bei Methoden mit Nebenwirkungen generell vermieden werden, es macht den Code unleserlich und bringt auch kaum Vorteile.

Ich habe kürzlich die ganzen Interpolations-Algoritmen in Math.NET Iridium revidiert, vielleicht findest du dort was du suchst. Du solltest dir aber direkt den Sourcecode aus dem Subversion Source Repository holen, denn die Algorithmen sind neuer als die aktuellste release (neue Release wird gegen Ende Woche erwartet).

Aber: Eine hochwertige Interpolation ist wahrscheinlich nicht die beste Lösung hier, ich schätze mit klassischem Resampling wärst du besser bedient: Einfach linear oder sogar nearest-neighbour interpolieren, und dann mit einem tiefpassfilter nachfiltern.

http://sebastien.lebreton.free.fr/reflexil/
http://sourceforge.net/projects/reflexil/

Was du suchst sind Raw Sockets. Offiziell Per Winsock geht das afaik ab XP SP2 aus "Sicherheitsgründen" nicht mehr. Glücklicherweise gibt's aber nicht nur Winsock ... ich habe selber vor einiger Zeit in einem Mischprojekt (C# Bibliothek mit C++/CLI Zwischenschicht) einen Wrapper für WinPcap (mit NPF Treiber) geschrieben und einige erste Protokolle implementiert, es ist also technisch möglich. Allerdings darf ich wohl in einem deutschen Forum keinen Code dazu posten, schliesslich kann man damit im lokalen Netzwerk alles mögliche anstellen 😉

Setze Background auf Transparent, sonst wird es beim Hit-Testing nicht berücksichtigt (sollte es normalerweise ja auch nicht, ist ja an sich ein reines Layout-Element).

Wenn es auch mit absoluten geht, perfekt - macht es einfacher 🙂

Text in WPF mit WinForms zu rendern macht imo wenig Sinn.

WPF 3 oder 3.5? Könntest du mal überprüfen ob du die aktuellsten Grafikkartentreiber installiert hast, und falls ja einen Screenshot eines kleinen repros posten, mit Xaml Source sowie Angaben zur Grafikkarte, Treiber (Version!) und Monitor? Kann ich allenfalls ans Text-Team weiterleiten...

OnRender zu überschreiben ist in WPF fast immer der falsche Weg.

Stichworte: Geometry, Shape, Path

http://msdn2.microsoft.com/en-us/library/ms751808.aspx
http://msdn2.microsoft.com/en-us/library/ms747393.aspx

Falls Min/Max dependency properties sind kannst du einfach einen property changed handler setzen (metadata) und darin die Geometrie neu aufbauen.

Versuch mal die Animation mit HandoffBehavior.Compose zu starten. Und generell mit relativen Änderungen statt absoluten (By statt From/To).

Stichwort zur Weitersuche: DoubleAnimation (System.Windows.Media.Animation Namespace).

Was spricht gegen einen ValueConverter?

Was spricht dagegen direkt den Scrollbar Style zu überschreiben, statt dem ganzen ScrollViewer?

Original von cordell
ich wollte nur mal fragen, wie/wo ich im Visual Studio 2005 die Einstellungen für 64Bit Gleitkommaarithmetik machen kann.

Für ein "C++/CLI" Projekt bei den Projekt-Einstellungen, unter:

Configuration Properties > C/C++ > Code Generation

(VS2005 kann nicht nur C# und VB.Net...)

Ich hätte mir schon mal etwas ähnliches gewünscht: Das Überschreiben (nicht überladen) mit einem Rückgabe-Typ der vom vorherigen Rückgabe-Typ ableitet:

class A {}
class B : A {}

class X
{
    public virtual A Foo()
    { ... }
}

class Y : X
{
    public override B Foo()
    { ... }
}

Wobei B zwingend von A erben muss. Afaik gibt es OO Sprachen die das unterstützen.

Es werden natürlich nicht 600 Stellen gespeichert. Aber die grösste darstellbare Zahl hat 308 Stellen vor dem Komma, die kleinste 324 Stellen nach dem Komma, macht insgesammt eine Differenz von mehr als 600 Stellen.

Btw, die Differenz der grössten darstellbaren Zahl und der zweitgrössten darstellbaren Zahl hat 292 Stellen vor dem Komma 😉

Mehr dazu giebt's z.b. bei Wikipedia.

Original von Nopileos
ich hatte da mehr so dran gedacht den double (oder float) mit seinem maximalen Wertebereich + 1 zu multiplizieren
da dann selbst wenn der hex 0000000000000001 ist und dann mit 10000000000000000 multipliziert wird kommt da 10000000000000000 raus also eine ganze Zahl nur leider entsteht dabei ein Überlauf.

Der Unterschied zwischen der kleinsten und grössten darstellbaren Zahl eines double beträgt mehr als 600 Stellen. Dürfte also schwierig werden 😉

Wobei man von "Zufallsklassen", die auf int basieren nicht zuviel erwarten sollte. Dazu ist der Zahlenbereich einfach zu klein. Näheres siehe
> .

So nutzlos sind sie auch wieder nicht (sofern man nicht aus irgendwelchen Gründen jedes mal mit einem neuen Seed initialisiert). Nicht vergessen, dass man auch mit nur einem einzigen Seed bereits genau so viele verschiedene Zufallsfolgen generieren kann wie die Periode des Generators lang ist (einfach jeweils versetzt; eigentlich eine zweite Seed-Dimension).

Wenn man bedenkt dass man z.B. mit einem mwc-rng Periodenlängen von 2^{131102 erreichen kann ist das einiges, und reicht problemlos um pro Seed alle Permutationen einer Folge von 10000 Elementen ( =2}118458 ) theoretisch direkt abbilden zu können. Iridium bietet beispielsweise einen RNG mit Periode 2^{19937, das reicht immerhin um pro Seed alle Permutationen einer Folge von 2000 Elementen ( =2}19052 ) theoretisch direkt abbilden zu können. Nicht dass es notwendig wäre die Permutationen direkt abbilden zu können...

edit: automatische smilies entfernt

edit2: -> Entscheidender als die Seedlänge ist also die Periodenlänge. Kennt zufällig jemand die Periodenlänge von System.Random und System.Security.Cryptography.RNGCryptoServiceProvider?

Btw, Math.NET Iridium hat solche Methoden fest eingebaut:

MathNet.Numerics.Combinatorics:

• int[] RandomPremutation(int n)
• bool[] RandomCombination(int n)
• bool[] RandomCombination(int n, int k)
• int[] RandomCombinationWithRepetition(int n, int k)
• int[] RandomVariation(int n, int k)
• int[] RandomVariationWithRepetition(int n, int k)
• void RandomShuffle<T>(IList<T> source, IList<T> target)
• void RandomShuffle<T>(IList<T> array)
• T[] RandomSubsetVariation<T>(IList<T> array, int numberToSelect)
• T[] RandomSubsetVariationWithRepetition<T>(IList<T> array, int numberToSelect)
• T[] RandomSubsetCombination<T>(IList<T> array, int numberToSelect)
• T[] RandomSubsetCombinationWithRepetition<T>(IList<T> array, int numberToSelect)

edit: wobei ich gerade gesehen habe dass die Klasse noch etwas Verbesserungspotential haben ... (-> nächste release..)

Nein, dein Ansatz (Kuehner) war schon richtig, die Notification soll unbedingt im Property Setter stehen. Aber was ist das für ne OnPropertyChange Methode?

Eine Lösung die funktioniert sieht etwa so aus (ohne Garantie, ist direkt hier so hingeschrieben):

public class MyObjectView : INotifyPropertyChanged
{
    private string _deviceName;

    public event PropertyChangedEventHandler PropertyChanged;

    public string DeviceName
    {
        get { return _deviceName; }
        set
        {
            if(value != _deviceName)
            {
                _deviceName = value;
                RaisePropertyChanged("DeviceName");
            }
        }
    }

    private void RaisePropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if(handler != null)
            handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

Müsste dann funktionieren. Sauberkeitshalber würde ich beim ToolTip Binding noch ", Mode=OneWay" und beim Text Binding ", Mode=TwoWay" ergänzen.

Kannst du den Code des Property Setters zeigen (der das Eregnis von INotifyPropertyChanged auslöst)?

edit: und die Bindings

Original von Borg
Du kannst auch die BigInteger-Klasse von J# verwenden. Die ist bei jedem Framework dabei.

Oder bereits .Net 3.5 verwendet, da gibt's im normalen Framework eine solche Klasse (im System.Numerics Namensraum) ...

Kannst du es vielleicht mit einem ValueConverter lösen? Da kann man ja einen Parameter angeben...

Original von HeinzTomato
Da lies sich doch nun wirklich nicht aufs Problem durch schließen, oder?

Tipp: Bei XamlParseException immer die InnerException oder die InnerException der InnerException ansehen, die tatsächlichen Fehler sind dort (gut) versteckt ...

Original von FZelle
Und welche vorteile wären das?

Zb. automatische Variablen (imo bessere Lösung als das using() {} Konstrukt in C#), sprachintegriertes Dispose/Finalize (statt dem Dispose() Zeug bei C#), bequemere Properties (Einzeiler, statt wie in C# wo man auch die gemappte Variable und die setter/getter explizit schreiben muss), etc. ....

Was du verwendest ist nicht "Managed C++" sondern "C++/CLI" (Nachfolger von Managed C++). Hilft dir vielleicht beim Suchen ...

Original von BelZebuB
2. Wofür steht in C++ .NET das ^, und wie schreibe ich darin ein Array?

In .NET gibt es Referenztypen und Werttypen.

^ = Objektzeiger/Referenz/Handle, verwendest du (zusammen mit gcnew/delete) für Referenztypen

C++/CLI hat einige recht nette Features die C# so nicht bietet, hat also durchaus auch ausserhalb von interop seine Berechtigung...

52! = 80658175170943878571660636856403766975289505440883277824000000000000

ln(52!) = 156.3608363

Wie gesagt: Du must für deine Formel keine einzige Fakultät tatsächlich berechnen...

Normalerweise berechnet man solche Terme logarithmisch, dann sind die grossen Zahlen kein Problem (und exp/ln kürzt sich praktischerweise oft weg). Also:

(a1a2)/(b1b2) = exp(ln(a1) + ln(a2) - ln(b1) - ln(b2))

Der Binomialkoeffizient ist übrigens in Math.NET Iridium fertig implementiert:

http://mathnet.opensourcedotnet.info/Iridium.aspx

Wenn du in erster Linie Klassenabhängigkeiten analysieren möchtest, dann ist (va. bei grösseren Projekten) eine Dependency Structure Matrix (DSM) wahrscheinlich viel hilfreicher als ein UML Klassendiagramm.

Hier gibt's ein freies DSM Plugin für den .NET Reflector. Das Plug-in kann auch zyklische Abhängigkeiten hervorheben, oft sehr hilfreich...

Ich setze VS05 ein, habe aber noch nie Add-Ins dazu entwickelt und kenne mich mit der Thematik und potentiellen Schwierigkeiten selber nicht aus.

zu 1:

Ich würde erwarten, dass ich danach fähig bin auch komplexere Add-Ins umzusetzen, ich müsste danach also mit den Paradigmen und vorgesehenen Design Patterns der VS API vertraut sein. Ich würde nicht unbedingt eine "klassiche" VS API Referenz erwarten - wenn ja, dann im Anhang, nicht im Haupttext. Ich würde erwarten dass ich recht früh im Text ein triviales Add-In selber schreiben könnte, und dass spezielle Aspekte im Detail später seperat aufgearbeitet werden, sodass ich nach den Basics auch direkt zu einem solchen Teil springen kann (ohne alle anderen Aspekte durchgelesen haben zu müssen). Und schlussendlich würde ich einige Beispiele erwarten, u.a. auch solche die sich direkt mit dem Source-Editor befassen und solche die direkt mit dem aktuellem Sourcecode integargieren.

zu 2: Ack zu herbivore.

In Code-Beispielen bevorzuge ich persönlich alles (bis auf Kommentare und String-Literale) auch englisch, also auch alle Members und Klassennamen.

Ich setze selber ein englisches VS ein, aber falls in der deutschen Version statt "Solution Explorer" etwas anderes im Fenster steht sollte eher diese deutsche Version benutzt werden - ausser der Text bezieht sich gezielt auf eine entsprechend englisch benannte Klasse aus dem Framework / VS Add-In API.

zu 5: Ack zu herbivore.

Hatte aber auch schon die Situation erlebt dass ich die einzlnen kurzen Codeausschnitte/Beispiele selber nicht wirklich (= nur mit viel Mehraufwand) zu etwas ganzem kombinieren konnte. Hilfreich wäre da vielleicht schon auch ein grösseres komplettes Beispiel, dies aber nicht abgedruckt sondern auf der Website oder vielleicht einer beigelegten CD (ohne dass es aber notwendig wird sich das lange Beispiel auch tatsächlich anzusehen um dem Text folgen zu können).

zu 6:

Ein Add-In sollte idealerweise einfach weitergegeben werden können. Wäre sicher hilfreich wenn das Thema so behandelt wird dass ich danach mein Add-In verpacken kann auch ohne bereits viel eigene Erfahrung mit Deployment zu haben; ohne aber allgemein in das Thema Deployment einzusteigen.

hth,
Chris

Situation:

• Einfache Library (ohne strong name) die keine speziellen Systemfunktionen benötigt und sich desshalb selber einschränkt mit

[assembly: PermissionSet(SecurityAction.RequestOptional, Name="Execution")]

• Unit Test für diese Library

• MsBuild Task der diesen UnitTest per Exec ausführt (NUnit + NCover; Continuous Integration...)

Wenn ich nun den Exec command (inkl. NCover) direkt auf der Shell (vom gleichen Ort mit gleichem NT user) ausführe funktioniert alles bestens, bei der Ausführung per MsBuild.exe (aus der gleichen Shell) krieg scheitern aber alle unit tests an einer verification exception:

System.TypeInitializationException : Der Typeninitialisierer für (...) hat eine Ausnahme verursacht. ----> System.Security.VerificationException : Dieser Vorgang kann die Laufzeit destabilisieren.

Die einfache Lösung wäre natürlich der Assembly einfach das FullTrust PermissionSet zu erlauben (statt nur Execution), aber das kann es nicht wirklich sein.

Kennt sich jemand mit Code Access Security aus? Im Zusammenhang mit MsBuild?

Update:

Wie erwartet:

[assembly: PermissionSet(SecurityAction.RequestOptional, Name="LocalIntranet")]

---> funktioniert nicht, gleicher Fehler

[assembly: PermissionSet(SecurityAction.RequestOptional, Name="FullTrust")]

---> funktioniert

Du hast richtig gefolgert, 14755052887786091 ist prim.

Ich werde wohl mal aussetzen, wäre wohl zu billig mit dem fertigen tool gegen eure selbstgeschriebenen algos anzutreten. Hatte übrigens Maple verwendet:

> with(numtheory):
> isprime(14755052887786091)     -> true
> ifactor(3452682375741945294)     -> (2) (3)^2 (13) (14755052887786091)

Maple implementiert übrigens den "Morrison-Brillhart" Algorithmus (man kann durch einen Parameter aber auch andere Algorithmen wählen: "D. Shanks' undocumented square-free factorization", "J.M. Pollard's rho method" und "Lenstra's elliptic curve method"). Google findet diverse Papers dazu...

Falls man noch etwas optimieren* möchte:

Math.DivMod berechnet n/8 und n%8 gleichzeitig. Bei früheren Architekturen war ausserdem "n>>3" schneller als "n/8", und "n&0x7" schneller als "n%8", gilt afaik heute aber nicht mehr.

Statt "Math.Pow(2, diff)" ist aber wahrscheinlich "1<<diff" etwas schneller.

detail: statt "if(cond) return true; else return false;" kann man auch einfach "return cond;" schreiben, aber ich schätze der compiler optimiert das ohnehin weg.

*müsste man aber immer profilen, nicht immer ist was schneller aussieht auch wirklich schneller; je besser der compiler je weniger ...

Original von ApfeL.
Außerdem wage ich mal die behauptung, dass die anzahl von Leuten, die ihr brot mit Linux Applikationen verdienen sehr gering bis nahezu 0 ist.
Linux ist und bleibt open source, und deshalb denke ich, dass kommerzielle Programme da kaum eine chance haben.

Mit Linux Anwendungen wird SEHR viel Geld umgesetzt, v.a. im technischen/industriellen Bereich (kein Wunder, dort trifft man auch gern mal Einzellizenzen im 6-stelligen € Bereich an...). Linux kompatibilität impliziert nicht opensource...

Was mir gerade auffällt:

public ref class CInnerTest
{
   public:
      int value;
};

public ref class COuterTest
{
   public:
      CInnerTest^ value;  // <--- 
};

ref Klassen solltest du immer mit ^ referenzieren.

btw: ist das noch managed C++, oder C++/CLI? Die Klassendefinition sieht mir eher nach C++/CLI aus.

Habe mit C++/CLI bisher gute Erfahrungen gemacht, gerade bei solchen managed Klassenhierarchien die dann direkt in C# verwendet werden ...

Ok, dann hab ich wohl eine interessante Grenze überschritten ... etwa 2^64?

Macht sonst mit der kleineren Zahl weiter, die ist noch als UInt64 speicherbar 😉

84926381637549237 = 3 * 23 * 373 * 49459 * 66717439

Fast Forward: 74270893012585041013206443057515

(Oder 742708930125850410 für kleinere Schritte)

392856483920471 = 2221*176882703251

Nächste Zahl: 3402316736605866

@talla: Ok ... nun, bis gut 100 Stellen ist meine Standardlösung noch dabei 😉

Btw, wäre es die Idee, dass man das verwendete Programm selber geschrieben hat? "Mein" Algorithmus ist zweifelsfrei leistungsstark, aber ich habe ihn nicht selber geschrieben, ja nicht mal selber kompiliert ...

84729023641 = 31 * 167 * 1289 * 12697

Nächste Zahl: 313497387653