mirror of https://github.com/icsharpcode/ILSpy.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1016 lines
39 KiB
1016 lines
39 KiB
// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this |
|
// software and associated documentation files (the "Software"), to deal in the Software |
|
// without restriction, including without limitation the rights to use, copy, modify, merge, |
|
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons |
|
// to whom the Software is furnished to do so, subject to the following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included in all copies or |
|
// substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, |
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE |
|
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
// DEALINGS IN THE SOFTWARE. |
|
|
|
using System; |
|
using System.ComponentModel; |
|
using System.Runtime.CompilerServices; |
|
|
|
using ICSharpCode.Decompiler.CSharp.OutputVisitor; |
|
|
|
namespace ICSharpCode.Decompiler |
|
{ |
|
/// <summary> |
|
/// Settings for the decompiler. |
|
/// </summary> |
|
public partial class DecompilerSettings : INotifyPropertyChanged |
|
{ |
|
/// <summary> |
|
/// Equivalent to <c>new DecompilerSettings(LanguageVersion.Latest)</c> |
|
/// </summary> |
|
public DecompilerSettings() |
|
{ |
|
} |
|
|
|
/// <summary> |
|
/// Creates a new DecompilerSettings instance with initial settings |
|
/// appropriate for the specified language version. |
|
/// </summary> |
|
/// <remarks> |
|
/// This does not imply that the resulting code strictly uses only language features from |
|
/// that version. Language constructs like generics or ref locals cannot be removed from |
|
/// the compiled code. |
|
/// The language version is a construction shortcut, not state: it initializes the feature |
|
/// flags once (see <see cref="SetLanguageVersion"/>) and is not stored afterwards. |
|
/// </remarks> |
|
public DecompilerSettings(CSharp.LanguageVersion languageVersion) |
|
{ |
|
SetLanguageVersion(languageVersion); |
|
} |
|
|
|
/// <summary> |
|
/// One-shot profile initializer: deactivates all language features from versions newer than |
|
/// <paramref name="languageVersion"/>. The version itself is not stored - the feature flags |
|
/// are the only state - so the call is not reversible and a later call with a higher version |
|
/// does not re-enable features. Use <see cref="GetMinimumRequiredVersion"/> to derive a |
|
/// version back from the flags. |
|
/// </summary> |
|
public partial void SetLanguageVersion(CSharp.LanguageVersion languageVersion); |
|
|
|
/// <summary> |
|
/// Derives the lowest language version that includes all currently enabled language |
|
/// features. The settings do not store a language version, so this derivation is how a |
|
/// version is recovered from the flags; project export uses it as the default (and lower |
|
/// bound) for the LangVersion written into the project file. |
|
/// </summary> |
|
public partial CSharp.LanguageVersion GetMinimumRequiredVersion(); |
|
|
|
/// <summary> |
|
/// Use C# 9 <c>nint</c>/<c>nuint</c> types. |
|
/// </summary> |
|
[Description("DecompilerSettings.NativeIntegers")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool NativeIntegers { get; set; } |
|
|
|
/// <summary> |
|
/// Treat <c>IntPtr</c>/<c>UIntPtr</c> as <c>nint</c>/<c>nuint</c>. |
|
/// </summary> |
|
[Description("DecompilerSettings.NumericIntPtr")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool NumericIntPtr { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile C# 9 covariant return types. |
|
/// </summary> |
|
[Description("DecompilerSettings.CovariantReturns")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool CovariantReturns { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 9 <c>init;</c> property accessors. |
|
/// </summary> |
|
[Description("DecompilerSettings.InitAccessors")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool InitAccessors { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 9 <c>record</c> classes. |
|
/// </summary> |
|
[Description("DecompilerSettings.RecordClasses")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool RecordClasses { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 10 <c>record</c> structs. |
|
/// </summary> |
|
[Description("DecompilerSettings.RecordStructs")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp10_0)] |
|
public partial bool RecordStructs { get; set; } |
|
|
|
/// <summary> |
|
/// Use field initializers in structs. |
|
/// </summary> |
|
[Description("DecompilerSettings.StructDefaultConstructorsAndFieldInitializers")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp10_0)] |
|
public partial bool StructDefaultConstructorsAndFieldInitializers { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 9 <c>with</c> initializer expressions. |
|
/// </summary> |
|
[Description("DecompilerSettings.WithExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool WithExpressions { get; set; } |
|
|
|
/// <summary> |
|
/// Use primary constructor syntax with records. |
|
/// </summary> |
|
[Description("DecompilerSettings.UsePrimaryConstructorSyntax")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool UsePrimaryConstructorSyntax { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 9 <c>delegate* unmanaged</c> types. |
|
/// If this option is disabled, function pointers will instead be decompiled with type `IntPtr`. |
|
/// </summary> |
|
[Description("DecompilerSettings.FunctionPointers")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool FunctionPointers { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 11 <c>scoped</c> modifier. |
|
/// </summary> |
|
[Description("DecompilerSettings.ScopedRef")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool ScopedRef { get; set; } |
|
|
|
[Obsolete("Renamed to ScopedRef. This property will be removed in a future version of the decompiler.")] |
|
[Browsable(false)] |
|
public bool LifetimeAnnotations { |
|
get { return ScopedRef; } |
|
set { ScopedRef = value; } |
|
} |
|
|
|
/// <summary> |
|
/// Use C# 11 <c>required</c> modifier. |
|
/// </summary> |
|
[Description("DecompilerSettings.RequiredMembers")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool RequiredMembers { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 8 switch expressions. |
|
/// </summary> |
|
[Description("DecompilerSettings.SwitchExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool SwitchExpressions { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 10 file-scoped namespaces. |
|
/// </summary> |
|
[Description("DecompilerSettings.FileScopedNamespaces")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp10_0)] |
|
public partial bool FileScopedNamespaces { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile anonymous methods/lambdas. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileAnonymousMethodsLambdas")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp2)] |
|
public partial bool AnonymousMethods { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile anonymous types. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileAnonymousTypes")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool AnonymousTypes { get; set; } |
|
|
|
/// <summary> |
|
/// Use C# 3 lambda syntax if possible. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseLambdaSyntaxIfPossible")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool UseLambdaSyntax { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile expression trees. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileExpressionTrees")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool ExpressionTrees { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile enumerators. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileEnumeratorsYieldReturn")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp2)] |
|
public partial bool YieldReturn { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile use of the 'dynamic' type. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileUseOfTheDynamicType")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp4)] |
|
public partial bool Dynamic { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile async methods. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileAsyncMethods")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp5)] |
|
public partial bool AsyncAwait { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile await in catch/finally blocks. |
|
/// Only has an effect if <see cref="AsyncAwait"/> is enabled. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileAwaitInCatchFinallyBlocks")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool AwaitInCatchFinally { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile IAsyncEnumerator/IAsyncEnumerable. |
|
/// Only has an effect if <see cref="AsyncAwait"/> is enabled. |
|
/// </summary> |
|
[Description("DecompilerSettings.AsyncEnumerator")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool AsyncEnumerator { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile [DecimalConstant(...)] as simple literal values. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileDecimalConstantAsSimpleLiteralValues")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool DecimalConstants { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile C# 1.0 'public unsafe fixed int arr[10];' members. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileC10PublicUnsafeFixedIntArr10Members")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool FixedBuffers { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile 'string.Concat(a, b)' calls into 'a + b'. |
|
/// </summary> |
|
[Description("DecompilerSettings.StringConcat")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool StringConcat { get; set; } |
|
|
|
/// <summary> |
|
/// Use lifted operators for nullables. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseLiftedOperatorsForNullables")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp2)] |
|
public partial bool LiftNullables { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile C# 6 ?. and ?[] operators. |
|
/// </summary> |
|
[Description("DecompilerSettings.NullPropagation")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool NullPropagation { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile automatic properties |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileAutomaticProperties")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool AutomaticProperties { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile getter-only automatic properties |
|
/// </summary> |
|
[Description("DecompilerSettings.GetterOnlyAutomaticProperties")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool GetterOnlyAutomaticProperties { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile automatic events |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileAutomaticEvents")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool AutomaticEvents { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile using statements. |
|
/// </summary> |
|
[Description("DecompilerSettings.DetectUsingStatements")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool UsingStatement { get; set; } |
|
|
|
/// <summary> |
|
/// Use enhanced using statements. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseEnhancedUsing")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool UseEnhancedUsing { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use braces for single-statement-blocks. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AlwaysUseBraces")] |
|
[DecompilerSetting] |
|
public partial bool AlwaysUseBraces { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile foreach statements. |
|
/// </summary> |
|
[Description("DecompilerSettings.DetectForeachStatements")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool ForEachStatement { get; set; } |
|
|
|
/// <summary> |
|
/// Support GetEnumerator extension methods in foreach. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileForEachWithGetEnumeratorExtension")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool ForEachWithGetEnumeratorExtension { get; set; } |
|
|
|
/// <summary> |
|
/// Support params collections. |
|
/// </summary> |
|
[Description("DecompilerSettings.DecompileParamsCollections")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp13_0)] |
|
public partial bool ParamsCollections { get; set; } |
|
|
|
/// <summary> |
|
/// Decompile lock statements. |
|
/// </summary> |
|
[Description("DecompilerSettings.DetectLockStatements")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool LockStatement { get; set; } |
|
|
|
[Description("DecompilerSettings.DetectSwitchOnString")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool SwitchStatementOnString { get; set; } |
|
|
|
[Description("DecompilerSettings.SparseIntegerSwitch")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool SparseIntegerSwitch { get; set; } |
|
|
|
[Description("DecompilerSettings.InsertUsingDeclarations")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool UsingDeclarations { get; set; } |
|
|
|
[Description("DecompilerSettings.UseExtensionMethodSyntax")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool ExtensionMethods { get; set; } |
|
|
|
[Description("DecompilerSettings.UseLINQExpressionSyntax")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool QueryExpressions { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 2.0 method group conversions. |
|
/// true: <c>EventHandler h = this.OnClick;</c> |
|
/// false: <c>EventHandler h = new EventHandler(this.OnClick);</c> |
|
/// </summary> |
|
[Description("DecompilerSettings.UseImplicitMethodGroupConversions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp2)] |
|
public partial bool UseImplicitMethodGroupConversion { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use object creation expressions for generic types with <c>new()</c> constraint. |
|
/// true: <c>T t = new T();</c> |
|
/// false: <c>T t = Activator.CreateInstance<T>()</c> |
|
/// </summary> |
|
[Description("DecompilerSettings.UseObjectCreationOfGenericTypeParameter")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp2)] |
|
public partial bool UseObjectCreationOfGenericTypeParameter { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to always cast targets to explicitly implemented methods. |
|
/// true: <c>((ISupportInitialize)pictureBox1).BeginInit();</c> |
|
/// false: <c>pictureBox1.BeginInit();</c> |
|
/// default: false |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AlwaysCastTargetsOfExplicitInterfaceImplementationCalls")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AlwaysCastTargetsOfExplicitInterfaceImplementationCalls { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to always qualify member references. |
|
/// true: <c>this.DoSomething();</c> |
|
/// false: <c>DoSomething();</c> |
|
/// default: false |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AlwaysQualifyMemberReferences")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AlwaysQualifyMemberReferences { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to always show enum member values. |
|
/// true: <c>enum Kind { A = 0, B = 1, C = 5 }</c> |
|
/// false: <c>enum Kind { A, B, C = 5 }</c> |
|
/// default: false |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AlwaysShowEnumMemberValues")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AlwaysShowEnumMemberValues { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use variable names from debug symbols, if available. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.UseVariableNamesFromDebugSymbolsIfAvailable")] |
|
[DecompilerSetting] |
|
public partial bool UseDebugSymbols { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use array initializers. |
|
/// If set to false, might produce non-compilable code. |
|
/// </summary> |
|
[Description("DecompilerSettings.ArrayInitializerExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool ArrayInitializers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 3.0 object/collection initializers. |
|
/// </summary> |
|
[Description("DecompilerSettings.ObjectCollectionInitializerExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp3)] |
|
public partial bool ObjectOrCollectionInitializers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 6.0 dictionary initializers. |
|
/// Only has an effect if ObjectOrCollectionInitializers is enabled. |
|
/// </summary> |
|
[Description("DecompilerSettings.DictionaryInitializerExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool DictionaryInitializers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 6.0 Extension Add methods in collection initializers. |
|
/// Only has an effect if ObjectOrCollectionInitializers is enabled. |
|
/// </summary> |
|
[Description("DecompilerSettings.AllowExtensionAddMethodsInCollectionInitializerExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool ExtensionMethodsInCollectionInitializers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use local ref variables in cases where this is necessary |
|
/// for re-compilation with a modern C# compiler to reproduce the same behavior |
|
/// as the original assembly produced with an old C# compiler that used an incorrect |
|
/// order of evaluation. |
|
/// See https://github.com/icsharpcode/ILSpy/issues/2050 |
|
/// </summary> |
|
[Description("DecompilerSettings.UseRefLocalsForAccurateOrderOfEvaluation")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool UseRefLocalsForAccurateOrderOfEvaluation { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 7.2 'ref' extension methods. |
|
/// </summary> |
|
[Description("DecompilerSettings.AllowExtensionMethodSyntaxOnRef")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_2)] |
|
public partial bool RefExtensionMethods { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 6.0 string interpolation |
|
/// </summary> |
|
[Description("DecompilerSettings.UseStringInterpolation")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool StringInterpolation { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 11.0 UTF-8 string literals |
|
/// </summary> |
|
[Description("DecompilerSettings.Utf8StringLiterals")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool Utf8StringLiterals { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 11.0 switch on (ReadOnly)Span<char> |
|
/// </summary> |
|
[Description("DecompilerSettings.SwitchOnReadOnlySpanChar")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool SwitchOnReadOnlySpanChar { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 11.0 unsigned right shift operator. |
|
/// </summary> |
|
[Description("DecompilerSettings.UnsignedRightShift")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool UnsignedRightShift { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use C# 11.0 user-defined checked operators. |
|
/// </summary> |
|
[Description("DecompilerSettings.CheckedOperators")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp11_0)] |
|
public partial bool CheckedOperators { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to include XML documentation comments in the decompiled code. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.IncludeXMLDocumentationCommentsInTheDecompiledCode")] |
|
[DecompilerSetting] |
|
public partial bool ShowXmlDocumentation { get; set; } |
|
|
|
[Browsable(false)] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool FoldBraces { get; set; } |
|
|
|
[Browsable(false)] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool ExpandXmlDocumentationComments { get; set; } |
|
|
|
[Browsable(false)] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool ExpandMemberDefinitions { get; set; } |
|
|
|
[Browsable(false)] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool ExpandUsingDeclarations { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether member bodies should be decompiled. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Browsable(false)] |
|
[DecompilerSetting] |
|
public partial bool DecompileMemberBodies { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether simple calculated getter-only property declarations |
|
/// should use expression body syntax. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseExpressionBodiedMemberSyntaxForGetOnlyProperties")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp6)] |
|
public partial bool UseExpressionBodyForCalculatedGetterOnlyProperties { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether out variable declarations should be used when possible. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseOutVariableDeclarations")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool OutVariables { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether discards should be used when possible. |
|
/// Only has an effect if <see cref="OutVariables"/> is enabled. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseDiscards")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool Discards { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether IsByRefLikeAttribute should be replaced with 'ref' modifiers on structs. |
|
/// </summary> |
|
[Description("DecompilerSettings.IsByRefLikeAttributeShouldBeReplacedWithRefModifiersOnStructs")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_2)] |
|
public partial bool IntroduceRefModifiersOnStructs { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether IsReadOnlyAttribute should be replaced with 'readonly' modifiers on structs |
|
/// and with the 'in' modifier on parameters. |
|
/// </summary> |
|
[Description("DecompilerSettings." + |
|
"IsReadOnlyAttributeShouldBeReplacedWithReadonlyInModifiersOnStructsParameters")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_2)] |
|
public partial bool IntroduceReadonlyAndInModifiers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether "private protected" should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.IntroducePrivateProtectedAccessibility")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_2)] |
|
public partial bool IntroducePrivateProtectedAccessibility { get; set; } |
|
|
|
[Description("DecompilerSettings.ReadOnlyMethods")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool ReadOnlyMethods { get; set; } |
|
|
|
[Description("DecompilerSettings.DetectAsyncUsingAndForeachStatements")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool AsyncUsingAndForEachStatement { get; set; } |
|
|
|
/// <summary> |
|
/// If this option is active, [IsUnmanagedAttribute] on type parameters |
|
/// is replaced with "T : unmanaged" constraints. |
|
/// </summary> |
|
[Description("DecompilerSettings." + |
|
"IsUnmanagedAttributeOnTypeParametersShouldBeReplacedWithUnmanagedConstraints")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_3)] |
|
public partial bool IntroduceUnmanagedConstraint { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 7.3 stackalloc initializers should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseStackallocInitializerSyntax")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_3)] |
|
public partial bool StackAllocInitializers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 7.3 pattern based fixed statement should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.UsePatternBasedFixedStatement")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_3)] |
|
public partial bool PatternBasedFixedStatement { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether tuple type syntax <c>(int, string)</c> |
|
/// should be used for <c>System.ValueTuple</c>. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseTupleTypeSyntax")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool TupleTypes { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether throw expressions should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseThrowExpressions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool ThrowExpressions { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether the C# 7.1 default literal <c>default</c> should be used instead of |
|
/// <c>default(T)</c>, wherever the surrounding syntax already supplies the type. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseDefaultLiterals")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_1)] |
|
public partial bool DefaultLiterals { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether implicit conversions between tuples |
|
/// should be used in the decompiled output. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseImplicitConversionsBetweenTupleTypes")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool TupleConversions { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether tuple comparisons should be detected. |
|
/// </summary> |
|
[Description("DecompilerSettings.DetectTupleComparisons")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_3)] |
|
public partial bool TupleComparisons { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether named arguments should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseNamedArguments")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp4)] |
|
public partial bool NamedArguments { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 7.2 non-trailing named arguments should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.UseNonTrailingNamedArguments")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7_2)] |
|
public partial bool NonTrailingNamedArguments { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether optional arguments should be removed, if possible. |
|
/// </summary> |
|
[Description("DecompilerSettings.RemoveOptionalArgumentsIfPossible")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp4)] |
|
public partial bool OptionalArguments { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to expand <c>params</c> arguments by replacing explicit array creation |
|
/// with individual values in method calls. |
|
/// </summary> |
|
[Description("DecompilerSettings.ExpandParamsArguments")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool ExpandParamsArguments { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 7.0 local functions should be transformed. |
|
/// </summary> |
|
[Description("DecompilerSettings.IntroduceLocalFunctions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool LocalFunctions { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 7.0 deconstruction should be detected. |
|
/// </summary> |
|
[Description("DecompilerSettings.Deconstruction")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool Deconstruction { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 7.0 pattern matching should be detected. |
|
/// </summary> |
|
[Description("DecompilerSettings.PatternMatching")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp7)] |
|
public partial bool PatternMatching { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 8.0 recursive patterns should be detected. |
|
/// </summary> |
|
[Description("DecompilerSettings.RecursivePatternMatching")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool RecursivePatternMatching { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 9.0 and, or, not patterns should be detected. |
|
/// </summary> |
|
[Description("DecompilerSettings.PatternCombinators")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool PatternCombinators { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 9.0 relational patterns should be detected. |
|
/// </summary> |
|
[Description("DecompilerSettings.RelationalPatterns")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp9_0)] |
|
public partial bool RelationalPatterns { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 8.0 static local functions should be transformed. |
|
/// </summary> |
|
[Description("DecompilerSettings.IntroduceStaticLocalFunctions")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool StaticLocalFunctions { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 8.0 index and range syntax should be used. |
|
/// </summary> |
|
[Description("DecompilerSettings.Ranges")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool Ranges { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 8.0 nullable reference types are enabled. |
|
/// </summary> |
|
[Description("DecompilerSettings.NullableReferenceTypes")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp8_0)] |
|
public partial bool NullableReferenceTypes { get; set; } |
|
|
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.ShowInfoFromDebugSymbolsIfAvailable")] |
|
[Browsable(false)] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool ShowDebugInfo { get; set; } |
|
#region Options to aid VB decompilation |
|
|
|
/// <summary> |
|
/// Gets/Sets whether the decompiler can assume that 'ldlen; conv.i4.ovf' |
|
/// does not throw an overflow exception. |
|
/// </summary> |
|
[Category("DecompilerSettings.VBSpecificOptions")] |
|
[Browsable(false)] |
|
[DecompilerSetting] |
|
public partial bool AssumeArrayLengthFitsIntoInt32 { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use increment and decrement operators |
|
/// </summary> |
|
[Category("DecompilerSettings.VBSpecificOptions")] |
|
[Browsable(false)] |
|
[DecompilerSetting] |
|
public partial bool IntroduceIncrementAndDecrement { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether to use assignment expressions such as in while ((count = Do()) != 0) ; |
|
/// </summary> |
|
[Category("DecompilerSettings.VBSpecificOptions")] |
|
[Browsable(false)] |
|
[DecompilerSetting] |
|
public partial bool MakeAssignmentExpressions { get; set; } |
|
#endregion |
|
#region Options to aid F# decompilation |
|
|
|
[Category("DecompilerSettings.FSpecificOptions")] |
|
[Description("DecompilerSettings.RemoveDeadAndSideEffectFreeCodeUseWithCaution")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool RemoveDeadCode { get; set; } |
|
|
|
[Category("DecompilerSettings.FSpecificOptions")] |
|
[Description("DecompilerSettings.RemoveDeadStores")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool RemoveDeadStores { get; set; } |
|
#endregion |
|
#region Assembly Load and Resolve options |
|
|
|
[Browsable(false)] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool LoadInMemory { get; set; } |
|
|
|
[Browsable(false)] |
|
[DecompilerSetting] |
|
public partial bool ThrowOnAssemblyResolveErrors { get; set; } |
|
|
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.ApplyWindowsRuntimeProjectionsOnLoadedAssemblies")] |
|
[DecompilerSetting] |
|
public partial bool ApplyWindowsRuntimeProjections { get; set; } |
|
|
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AutoLoadAssemblyReferences")] |
|
[DecompilerSetting] |
|
public partial bool AutoLoadAssemblyReferences { get; set; } |
|
#endregion |
|
|
|
/// <summary> |
|
/// Gets/sets whether the decompiler should produce for loops. |
|
/// </summary> |
|
[Description("DecompilerSettings.ForStatement")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool ForStatement { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/sets whether the decompiler should produce do-while loops. |
|
/// </summary> |
|
[Description("DecompilerSettings.DoWhileStatement")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp1)] |
|
public partial bool DoWhileStatement { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/sets whether RequiresLocationAttribute on parameters should be replaced with 'ref readonly' modifiers. |
|
/// </summary> |
|
[Description("DecompilerSettings.RefReadOnlyParameters")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp12_0)] |
|
public partial bool RefReadOnlyParameters { get; set; } |
|
|
|
/// <summary> |
|
/// Use primary constructor syntax with classes and structs. |
|
/// </summary> |
|
[Description("DecompilerSettings.UsePrimaryConstructorSyntaxForNonRecordTypes")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp12_0)] |
|
public partial bool UsePrimaryConstructorSyntaxForNonRecordTypes { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 12.0 inline array uses should be transformed. |
|
/// </summary> |
|
[Description("DecompilerSettings.InlineArrays")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp12_0)] |
|
public partial bool InlineArrays { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/sets whether lambda parameter lists may declare 'params' and parameter default |
|
/// values. When disabled, these modifiers are dropped from anonymous functions instead. |
|
/// </summary> |
|
[Description("DecompilerSettings.LambdaOptionalAndParamsParameters")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp12_0)] |
|
public partial bool LambdaOptionalAndParamsParameters { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether C# 14.0 extension members should be transformed. |
|
/// </summary> |
|
[Description("DecompilerSettings.ExtensionMembers")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp14_0)] |
|
public partial bool ExtensionMembers { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether (ReadOnly)Span<T> should be treated like built-in types. |
|
/// </summary> |
|
[Description("DecompilerSettings.FirstClassSpanTypes")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp14_0)] |
|
public partial bool FirstClassSpanTypes { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/Sets whether property accessors should use the C# 14.0 "field" keyword to |
|
/// refer to the compiler-generated backing field. |
|
/// </summary> |
|
[Description("DecompilerSettings.FieldKeyword")] |
|
[DecompilerSetting(CSharp.LanguageVersion.CSharp14_0)] |
|
public partial bool FieldKeyword { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/sets whether the decompiler should separate local variable declarations |
|
/// from their initialization. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.SeparateLocalVariableDeclarations")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool SeparateLocalVariableDeclarations { get; set; } |
|
|
|
/// <summary> |
|
/// Gets or sets a value indicating whether the new SDK style format |
|
/// shall be used for the generated project files. |
|
/// </summary> |
|
[Category("DecompilerSettings.ProjectExport")] |
|
[Description("DecompilerSettings.UseSdkStyleProjectFormat")] |
|
[DecompilerSetting] |
|
public partial bool UseSdkStyleProjectFormat { get; set; } |
|
|
|
/// <summary> |
|
/// Gets/sets whether namespaces and namespace-like identifiers should be split at '.' |
|
/// and each part should produce a new level of nesting in the output directory structure. |
|
/// </summary> |
|
[Category("DecompilerSettings.ProjectExport")] |
|
[Description("DecompilerSettings.UseNestedDirectoriesForNamespaces")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool UseNestedDirectoriesForNamespaces { get; set; } |
|
|
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AggressiveScalarReplacementOfAggregates")] |
|
// TODO : Remove once https://github.com/icsharpcode/ILSpy/issues/2032 is fixed. |
|
#if !DEBUG |
|
[Browsable(false)] |
|
#endif |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AggressiveScalarReplacementOfAggregates { get; set; } |
|
|
|
/// <summary> |
|
/// If set to false (the default), the decompiler will inline local variables only when they occur |
|
/// in a context where the C# compiler is known to emit compiler-generated locals. |
|
/// If set to true, the decompiler will inline local variables whenever possible. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AggressiveInlining")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AggressiveInlining { get; set; } |
|
|
|
/// <summary> |
|
/// Always fully qualify namespaces using the "global::" prefix. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AlwaysUseGlobal")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AlwaysUseGlobal { get; set; } |
|
|
|
/// <summary> |
|
/// If set to false (the default), the decompiler will move field initializers at the start of constructors |
|
/// to their respective field declarations (TransformFieldAndConstructorInitializers) only when the declaring |
|
/// type has BeforeFieldInit or the member IsConst. |
|
/// If set true, the decompiler will always move them regardless of the flags. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.AlwaysMoveInitializer")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool AlwaysMoveInitializer { get; set; } |
|
|
|
/// <summary> |
|
/// Sort custom attributes. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.SortCustomAttributes")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool SortCustomAttributes { get; set; } |
|
|
|
/// <summary> |
|
/// Sort switch sections by their label value instead of by IL offset. |
|
/// Useful when diffing decompiler output across rebuilds of obfuscated assemblies, |
|
/// where IL block layout is unstable but the case-to-value mapping is not. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.SortSwitchSections")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool SortSwitchSections { get; set; } |
|
|
|
/// <summary> |
|
/// Check for overflow and underflow in operators. |
|
/// </summary> |
|
[Category("DecompilerSettings.Other")] |
|
[Description("DecompilerSettings.CheckForOverflowUnderflow")] |
|
[DecompilerSetting(DefaultValue = false)] |
|
public partial bool CheckForOverflowUnderflow { get; set; } |
|
|
|
CSharpFormattingOptions csharpFormattingOptions; |
|
|
|
[Browsable(false)] |
|
public CSharpFormattingOptions CSharpFormattingOptions { |
|
get { |
|
if (csharpFormattingOptions == null) |
|
{ |
|
csharpFormattingOptions = FormattingOptionsFactory.CreateAllman(); |
|
csharpFormattingOptions.IndentSwitchBody = false; |
|
csharpFormattingOptions.ArrayInitializerWrapping = Wrapping.WrapIfTooLong; |
|
csharpFormattingOptions.AutoPropertyFormatting = PropertyFormatting.SingleLine; |
|
} |
|
return csharpFormattingOptions; |
|
} |
|
set { |
|
if (value == null) |
|
throw new ArgumentNullException(); |
|
if (csharpFormattingOptions != value) |
|
{ |
|
csharpFormattingOptions = value; |
|
OnPropertyChanged(); |
|
} |
|
} |
|
} |
|
|
|
public event PropertyChangedEventHandler PropertyChanged; |
|
|
|
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) |
|
{ |
|
if (PropertyChanged != null) |
|
{ |
|
PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); |
|
} |
|
} |
|
|
|
public virtual DecompilerSettings Clone() |
|
{ |
|
DecompilerSettings settings = (DecompilerSettings)MemberwiseClone(); |
|
if (csharpFormattingOptions != null) |
|
settings.csharpFormattingOptions = csharpFormattingOptions.Clone(); |
|
settings.PropertyChanged = null; |
|
return settings; |
|
} |
|
} |
|
}
|
|
|