Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Contribute to GitLab
Sign in / Register
Toggle navigation
T
Titanium-Web-Proxy
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
Administrator
Titanium-Web-Proxy
Commits
64ce8071
Commit
64ce8071
authored
Jun 24, 2017
by
Honfika
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Gui example project added (Which also makes finding bugs in TWP easier)
parent
1c0447ee
Show whitespace changes
Inline
Side-by-side
Showing
15 changed files
with
1806 additions
and
0 deletions
+1806
-0
App.config
Examples/Titanium.Web.Proxy.Examples.Wpf/App.config
+6
-0
App.xaml
Examples/Titanium.Web.Proxy.Examples.Wpf/App.xaml
+9
-0
App.xaml.cs
Examples/Titanium.Web.Proxy.Examples.Wpf/App.xaml.cs
+17
-0
MainWindow.xaml
Examples/Titanium.Web.Proxy.Examples.Wpf/MainWindow.xaml
+33
-0
MainWindow.xaml.cs
Examples/Titanium.Web.Proxy.Examples.Wpf/MainWindow.xaml.cs
+163
-0
Annotations.cs
...Titanium.Web.Proxy.Examples.Wpf/Properties/Annotations.cs
+1048
-0
AssemblyInfo.cs
...itanium.Web.Proxy.Examples.Wpf/Properties/AssemblyInfo.cs
+55
-0
Resources.Designer.cs
...m.Web.Proxy.Examples.Wpf/Properties/Resources.Designer.cs
+63
-0
Resources.resx
...Titanium.Web.Proxy.Examples.Wpf/Properties/Resources.resx
+117
-0
Settings.Designer.cs
...um.Web.Proxy.Examples.Wpf/Properties/Settings.Designer.cs
+26
-0
Settings.settings
...anium.Web.Proxy.Examples.Wpf/Properties/Settings.settings
+7
-0
SessionListItem.cs
Examples/Titanium.Web.Proxy.Examples.Wpf/SessionListItem.cs
+125
-0
Titanium.Web.Proxy.Examples.Wpf.csproj
...Proxy.Examples.Wpf/Titanium.Web.Proxy.Examples.Wpf.csproj
+129
-0
Titanium.Web.Proxy.sln
Titanium.Web.Proxy.sln
+7
-0
Titanium.Web.Proxy.sln.DotSettings
Titanium.Web.Proxy.sln.DotSettings
+1
-0
No files found.
Examples/Titanium.Web.Proxy.Examples.Wpf/App.config
0 → 100644
View file @
64ce8071
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<
configuration
>
<
startup
>
<
supportedRuntime
version
=
"v4.0"
sku
=
".NETFramework,Version=v4.5"
/>
</
startup
>
</
configuration
>
Examples/Titanium.Web.Proxy.Examples.Wpf/App.xaml
0 → 100644
View file @
64ce8071
<Application x:Class="Titanium.Web.Proxy.Examples.Wpf.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:Titanium.Web.Proxy.Examples.Wpf"
StartupUri="MainWindow.xaml">
<Application.Resources>
</Application.Resources>
</Application>
Examples/Titanium.Web.Proxy.Examples.Wpf/App.xaml.cs
0 → 100644
View file @
64ce8071
using
System
;
using
System.Collections.Generic
;
using
System.Configuration
;
using
System.Data
;
using
System.Linq
;
using
System.Threading.Tasks
;
using
System.Windows
;
namespace
Titanium.Web.Proxy.Examples.Wpf
{
/// <summary>
/// Interaction logic for App.xaml
/// </summary>
public
partial
class
App
:
Application
{
}
}
Examples/Titanium.Web.Proxy.Examples.Wpf/MainWindow.xaml
0 → 100644
View file @
64ce8071
<Window x:Class="Titanium.Web.Proxy.Examples.Wpf.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:Titanium.Web.Proxy.Examples.Wpf"
mc:Ignorable="d"
Title="MainWindow" Height="500" Width="1000" WindowState="Maximized"
DataContext="{Binding RelativeSource={RelativeSource Self}}">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="500" />
<ColumnDefinition Width="3" />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<GridSplitter Grid.Column="1" HorizontalAlignment="Stretch" />
<ListView Grid.Column="0" HorizontalAlignment="Stretch" ItemsSource="{Binding Sessions}" SelectedItem="{Binding SelectedSession}"
KeyDown="ListViewSessions_OnKeyDown">
<ListView.View>
<GridView>
<GridViewColumn Header="Result" DisplayMemberBinding="{Binding StatusCode}" />
<GridViewColumn Header="Protocol" DisplayMemberBinding="{Binding Protocol}" />
<GridViewColumn Header="Host" DisplayMemberBinding="{Binding Host}" />
<GridViewColumn Header="Url" DisplayMemberBinding="{Binding Url}" />
<GridViewColumn Header="BodySize" DisplayMemberBinding="{Binding BodySize}" />
<GridViewColumn Header="Process" DisplayMemberBinding="{Binding Process}" />
<GridViewColumn Header="SentBytes" DisplayMemberBinding="{Binding SentDataCount}" />
<GridViewColumn Header="ReceivedBytes" DisplayMemberBinding="{Binding ReceivedDataCount}" />
</GridView>
</ListView.View>
</ListView>
</Grid>
</Window>
Examples/Titanium.Web.Proxy.Examples.Wpf/MainWindow.xaml.cs
0 → 100644
View file @
64ce8071
using
System
;
using
System.Collections.Generic
;
using
System.Collections.ObjectModel
;
using
System.Linq
;
using
System.Net
;
using
System.Text
;
using
System.Threading.Tasks
;
using
System.Windows
;
using
System.Windows.Controls
;
using
System.Windows.Data
;
using
System.Windows.Documents
;
using
System.Windows.Input
;
using
System.Windows.Media
;
using
System.Windows.Media.Imaging
;
using
System.Windows.Navigation
;
using
System.Windows.Shapes
;
using
Titanium.Web.Proxy.EventArguments
;
using
Titanium.Web.Proxy.Helpers
;
using
Titanium.Web.Proxy.Models
;
namespace
Titanium.Web.Proxy.Examples.Wpf
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public
partial
class
MainWindow
:
Window
{
private
readonly
ProxyServer
proxyServer
;
private
int
lastSessionNumber
;
public
ObservableCollection
<
SessionListItem
>
Sessions
{
get
;
}
=
new
ObservableCollection
<
SessionListItem
>();
public
SessionListItem
SelectedSession
{
get
;
set
;
}
private
readonly
Dictionary
<
SessionEventArgs
,
SessionListItem
>
sessionDictionary
=
new
Dictionary
<
SessionEventArgs
,
SessionListItem
>();
public
MainWindow
()
{
proxyServer
=
new
ProxyServer
();
proxyServer
.
TrustRootCertificate
=
true
;
proxyServer
.
ForwardToUpstreamGateway
=
true
;
var
explicitEndPoint
=
new
ExplicitProxyEndPoint
(
IPAddress
.
Any
,
8000
,
true
);
proxyServer
.
AddEndPoint
(
explicitEndPoint
);
proxyServer
.
BeforeRequest
+=
ProxyServer_BeforeRequest
;
proxyServer
.
BeforeResponse
+=
ProxyServer_BeforeResponse
;
proxyServer
.
TunnelConnectRequest
+=
ProxyServer_TunnelConnectRequest
;
proxyServer
.
TunnelConnectResponse
+=
ProxyServer_TunnelConnectResponse
;
proxyServer
.
Start
();
proxyServer
.
SetAsSystemProxy
(
explicitEndPoint
,
ProxyProtocolType
.
AllHttp
);
InitializeComponent
();
}
private
async
Task
ProxyServer_TunnelConnectRequest
(
object
sender
,
TunnelConnectSessionEventArgs
e
)
{
Dispatcher
.
Invoke
(()
=>
{
AddSession
(
e
);
});
}
private
async
Task
ProxyServer_TunnelConnectResponse
(
object
sender
,
SessionEventArgs
e
)
{
Dispatcher
.
Invoke
(()
=>
{
SessionListItem
item
;
if
(
sessionDictionary
.
TryGetValue
(
e
,
out
item
))
{
item
.
Update
();
}
});
}
private
async
Task
ProxyServer_BeforeRequest
(
object
sender
,
SessionEventArgs
e
)
{
Dispatcher
.
Invoke
(()
=>
{
AddSession
(
e
);
});
}
private
async
Task
ProxyServer_BeforeResponse
(
object
sender
,
SessionEventArgs
e
)
{
Dispatcher
.
Invoke
(()
=>
{
SessionListItem
item
;
if
(
sessionDictionary
.
TryGetValue
(
e
,
out
item
))
{
item
.
Update
();
}
});
}
private
void
AddSession
(
SessionEventArgs
e
)
{
var
item
=
CreateSessionListItem
(
e
);
Sessions
.
Add
(
item
);
sessionDictionary
.
Add
(
e
,
item
);
}
private
SessionListItem
CreateSessionListItem
(
SessionEventArgs
e
)
{
lastSessionNumber
++;
var
item
=
new
SessionListItem
{
Number
=
lastSessionNumber
,
SessionArgs
=
e
,
};
if
(
e
is
TunnelConnectSessionEventArgs
)
{
e
.
DataReceived
+=
(
sender
,
args
)
=>
{
var
session
=
(
SessionEventArgs
)
sender
;
SessionListItem
li
;
if
(
sessionDictionary
.
TryGetValue
(
session
,
out
li
))
{
li
.
ReceivedDataCount
+=
args
.
Count
;
}
};
e
.
DataSent
+=
(
sender
,
args
)
=>
{
var
session
=
(
SessionEventArgs
)
sender
;
SessionListItem
li
;
if
(
sessionDictionary
.
TryGetValue
(
session
,
out
li
))
{
li
.
SentDataCount
+=
args
.
Count
;
}
};
}
item
.
Update
();
return
item
;
}
private
void
Session_DataReceived
(
object
sender
,
EventArgs
e
)
{
Dispatcher
.
Invoke
(()
=>
{
var
session
=
(
SessionEventArgs
)
sender
;
SessionListItem
item
;
if
(
sessionDictionary
.
TryGetValue
(
session
,
out
item
))
{
item
.
Update
();
}
});
}
private
void
ListViewSessions_OnKeyDown
(
object
sender
,
KeyEventArgs
e
)
{
var
selectedItems
=
((
ListView
)
sender
).
SelectedItems
;
foreach
(
var
item
in
selectedItems
.
Cast
<
SessionListItem
>().
ToArray
())
{
Sessions
.
Remove
(
item
);
sessionDictionary
.
Remove
(
item
.
SessionArgs
);
}
}
}
}
Examples/Titanium.Web.Proxy.Examples.Wpf/Properties/Annotations.cs
0 → 100644
View file @
64ce8071
/* MIT License
Copyright (c) 2016 JetBrains http://www.jetbrains.com
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
;
#pragma warning disable 1591
// ReSharper disable UnusedMember.Global
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedAutoPropertyAccessor.Global
// ReSharper disable IntroduceOptionalParameters.Global
// ReSharper disable MemberCanBeProtected.Global
// ReSharper disable InconsistentNaming
namespace
Titanium.Web.Proxy.Examples.Wpf.Annotations
{
/// <summary>
/// Indicates that the value of the marked element could be <c>null</c> sometimes,
/// so the check for <c>null</c> is necessary before its usage.
/// </summary>
/// <example><code>
/// [CanBeNull] object Test() => null;
///
/// void UseTest() {
/// var p = Test();
/// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Method
|
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
|
AttributeTargets
.
Delegate
|
AttributeTargets
.
Field
|
AttributeTargets
.
Event
|
AttributeTargets
.
Class
|
AttributeTargets
.
Interface
|
AttributeTargets
.
GenericParameter
)]
public
sealed
class
CanBeNullAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that the value of the marked element could never be <c>null</c>.
/// </summary>
/// <example><code>
/// [NotNull] object Foo() {
/// return null; // Warning: Possible 'null' assignment
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Method
|
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
|
AttributeTargets
.
Delegate
|
AttributeTargets
.
Field
|
AttributeTargets
.
Event
|
AttributeTargets
.
Class
|
AttributeTargets
.
Interface
|
AttributeTargets
.
GenericParameter
)]
public
sealed
class
NotNullAttribute
:
Attribute
{
}
/// <summary>
/// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
/// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
/// or of the Lazy.Value property can never be null.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Method
|
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
|
AttributeTargets
.
Delegate
|
AttributeTargets
.
Field
)]
public
sealed
class
ItemNotNullAttribute
:
Attribute
{
}
/// <summary>
/// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
/// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
/// or of the Lazy.Value property can be null.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Method
|
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
|
AttributeTargets
.
Delegate
|
AttributeTargets
.
Field
)]
public
sealed
class
ItemCanBeNullAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that the marked method builds string by format pattern and (optional) arguments.
/// Parameter, which contains format string, should be given in constructor. The format string
/// should be in <see cref="string.Format(IFormatProvider,string,object[])"/>-like form.
/// </summary>
/// <example><code>
/// [StringFormatMethod("message")]
/// void ShowError(string message, params object[] args) { /* do something */ }
///
/// void Foo() {
/// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Constructor
|
AttributeTargets
.
Method
|
AttributeTargets
.
Property
|
AttributeTargets
.
Delegate
)]
public
sealed
class
StringFormatMethodAttribute
:
Attribute
{
/// <param name="formatParameterName">
/// Specifies which parameter of an annotated method should be treated as format-string
/// </param>
public
StringFormatMethodAttribute
([
NotNull
]
string
formatParameterName
)
{
FormatParameterName
=
formatParameterName
;
}
[
NotNull
]
public
string
FormatParameterName
{
get
;
private
set
;
}
}
/// <summary>
/// For a parameter that is expected to be one of the limited set of values.
/// Specify fields of which type should be used as values for this parameter.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
|
AttributeTargets
.
Field
,
AllowMultiple
=
true
)]
public
sealed
class
ValueProviderAttribute
:
Attribute
{
public
ValueProviderAttribute
([
NotNull
]
string
name
)
{
Name
=
name
;
}
[
NotNull
]
public
string
Name
{
get
;
private
set
;
}
}
/// <summary>
/// Indicates that the function argument should be string literal and match one
/// of the parameters of the caller function. For example, ReSharper annotates
/// the parameter of <see cref="System.ArgumentNullException"/>.
/// </summary>
/// <example><code>
/// void Foo(string param) {
/// if (param == null)
/// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
InvokerParameterNameAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that the method is contained in a type that implements
/// <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
/// is used to notify that some property value changed.
/// </summary>
/// <remarks>
/// The method should be non-static and conform to one of the supported signatures:
/// <list>
/// <item><c>NotifyChanged(string)</c></item>
/// <item><c>NotifyChanged(params string[])</c></item>
/// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
/// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
/// <item><c>SetProperty{T}(ref T, T, string)</c></item>
/// </list>
/// </remarks>
/// <example><code>
/// public class Foo : INotifyPropertyChanged {
/// public event PropertyChangedEventHandler PropertyChanged;
///
/// [NotifyPropertyChangedInvocator]
/// protected virtual void NotifyChanged(string propertyName) { ... }
///
/// string _name;
///
/// public string Name {
/// get { return _name; }
/// set { _name = value; NotifyChanged("LastName"); /* Warning */ }
/// }
/// }
/// </code>
/// Examples of generated notifications:
/// <list>
/// <item><c>NotifyChanged("Property")</c></item>
/// <item><c>NotifyChanged(() => Property)</c></item>
/// <item><c>NotifyChanged((VM x) => x.Property)</c></item>
/// <item><c>SetProperty(ref myField, value, "Property")</c></item>
/// </list>
/// </example>
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
NotifyPropertyChangedInvocatorAttribute
:
Attribute
{
public
NotifyPropertyChangedInvocatorAttribute
()
{
}
public
NotifyPropertyChangedInvocatorAttribute
([
NotNull
]
string
parameterName
)
{
ParameterName
=
parameterName
;
}
[
CanBeNull
]
public
string
ParameterName
{
get
;
private
set
;
}
}
/// <summary>
/// Describes dependency between method input and output.
/// </summary>
/// <syntax>
/// <p>Function Definition Table syntax:</p>
/// <list>
/// <item>FDT ::= FDTRow [;FDTRow]*</item>
/// <item>FDTRow ::= Input => Output | Output <= Input</item>
/// <item>Input ::= ParameterName: Value [, Input]*</item>
/// <item>Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
/// <item>Value ::= true | false | null | notnull | canbenull</item>
/// </list>
/// If method has single input parameter, it's name could be omitted.<br/>
/// Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for method output
/// means that the methos doesn't return normally (throws or terminates the process).<br/>
/// Value <c>canbenull</c> is only applicable for output parameters.<br/>
/// You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
/// with rows separated by semicolon. There is no notion of order rows, all rows are checked
/// for applicability and applied per each program state tracked by R# analysis.<br/>
/// </syntax>
/// <examples><list>
/// <item><code>
/// [ContractAnnotation("=> halt")]
/// public void TerminationMethod()
/// </code></item>
/// <item><code>
/// [ContractAnnotation("halt <= condition: false")]
/// public void Assert(bool condition, string text) // regular assertion method
/// </code></item>
/// <item><code>
/// [ContractAnnotation("s:null => true")]
/// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
/// </code></item>
/// <item><code>
/// // A method that returns null if the parameter is null,
/// // and not null if the parameter is not null
/// [ContractAnnotation("null => null; notnull => notnull")]
/// public object Transform(object data)
/// </code></item>
/// <item><code>
/// [ContractAnnotation("=> true, result: notnull; => false, result: null")]
/// public bool TryParse(string s, out Person result)
/// </code></item>
/// </list></examples>
[
AttributeUsage
(
AttributeTargets
.
Method
,
AllowMultiple
=
true
)]
public
sealed
class
ContractAnnotationAttribute
:
Attribute
{
public
ContractAnnotationAttribute
([
NotNull
]
string
contract
)
:
this
(
contract
,
false
)
{
}
public
ContractAnnotationAttribute
([
NotNull
]
string
contract
,
bool
forceFullStates
)
{
Contract
=
contract
;
ForceFullStates
=
forceFullStates
;
}
[
NotNull
]
public
string
Contract
{
get
;
private
set
;
}
public
bool
ForceFullStates
{
get
;
private
set
;
}
}
/// <summary>
/// Indicates that marked element should be localized or not.
/// </summary>
/// <example><code>
/// [LocalizationRequiredAttribute(true)]
/// class Foo {
/// string str = "my string"; // Warning: Localizable string
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
All
)]
public
sealed
class
LocalizationRequiredAttribute
:
Attribute
{
public
LocalizationRequiredAttribute
()
:
this
(
true
)
{
}
public
LocalizationRequiredAttribute
(
bool
required
)
{
Required
=
required
;
}
public
bool
Required
{
get
;
private
set
;
}
}
/// <summary>
/// Indicates that the value of the marked type (or its derivatives)
/// cannot be compared using '==' or '!=' operators and <c>Equals()</c>
/// should be used instead. However, using '==' or '!=' for comparison
/// with <c>null</c> is always permitted.
/// </summary>
/// <example><code>
/// [CannotApplyEqualityOperator]
/// class NoEquality { }
///
/// class UsesNoEquality {
/// void Test() {
/// var ca1 = new NoEquality();
/// var ca2 = new NoEquality();
/// if (ca1 != null) { // OK
/// bool condition = ca1 == ca2; // Warning
/// }
/// }
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Interface
|
AttributeTargets
.
Class
|
AttributeTargets
.
Struct
)]
public
sealed
class
CannotApplyEqualityOperatorAttribute
:
Attribute
{
}
/// <summary>
/// When applied to a target attribute, specifies a requirement for any type marked
/// with the target attribute to implement or inherit specific type or types.
/// </summary>
/// <example><code>
/// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
/// class ComponentAttribute : Attribute { }
///
/// [Component] // ComponentAttribute requires implementing IComponent interface
/// class MyComponent : IComponent { }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Class
,
AllowMultiple
=
true
)]
[
BaseTypeRequired
(
typeof
(
Attribute
))]
public
sealed
class
BaseTypeRequiredAttribute
:
Attribute
{
public
BaseTypeRequiredAttribute
([
NotNull
]
Type
baseType
)
{
BaseType
=
baseType
;
}
[
NotNull
]
public
Type
BaseType
{
get
;
private
set
;
}
}
/// <summary>
/// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
/// so this symbol will not be marked as unused (as well as by other usage inspections).
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
All
)]
public
sealed
class
UsedImplicitlyAttribute
:
Attribute
{
public
UsedImplicitlyAttribute
()
:
this
(
ImplicitUseKindFlags
.
Default
,
ImplicitUseTargetFlags
.
Default
)
{
}
public
UsedImplicitlyAttribute
(
ImplicitUseKindFlags
useKindFlags
)
:
this
(
useKindFlags
,
ImplicitUseTargetFlags
.
Default
)
{
}
public
UsedImplicitlyAttribute
(
ImplicitUseTargetFlags
targetFlags
)
:
this
(
ImplicitUseKindFlags
.
Default
,
targetFlags
)
{
}
public
UsedImplicitlyAttribute
(
ImplicitUseKindFlags
useKindFlags
,
ImplicitUseTargetFlags
targetFlags
)
{
UseKindFlags
=
useKindFlags
;
TargetFlags
=
targetFlags
;
}
public
ImplicitUseKindFlags
UseKindFlags
{
get
;
private
set
;
}
public
ImplicitUseTargetFlags
TargetFlags
{
get
;
private
set
;
}
}
/// <summary>
/// Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes
/// as unused (as well as by other usage inspections)
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Class
|
AttributeTargets
.
GenericParameter
)]
public
sealed
class
MeansImplicitUseAttribute
:
Attribute
{
public
MeansImplicitUseAttribute
()
:
this
(
ImplicitUseKindFlags
.
Default
,
ImplicitUseTargetFlags
.
Default
)
{
}
public
MeansImplicitUseAttribute
(
ImplicitUseKindFlags
useKindFlags
)
:
this
(
useKindFlags
,
ImplicitUseTargetFlags
.
Default
)
{
}
public
MeansImplicitUseAttribute
(
ImplicitUseTargetFlags
targetFlags
)
:
this
(
ImplicitUseKindFlags
.
Default
,
targetFlags
)
{
}
public
MeansImplicitUseAttribute
(
ImplicitUseKindFlags
useKindFlags
,
ImplicitUseTargetFlags
targetFlags
)
{
UseKindFlags
=
useKindFlags
;
TargetFlags
=
targetFlags
;
}
[
UsedImplicitly
]
public
ImplicitUseKindFlags
UseKindFlags
{
get
;
private
set
;
}
[
UsedImplicitly
]
public
ImplicitUseTargetFlags
TargetFlags
{
get
;
private
set
;
}
}
[
Flags
]
public
enum
ImplicitUseKindFlags
{
Default
=
Access
|
Assign
|
InstantiatedWithFixedConstructorSignature
,
/// <summary>Only entity marked with attribute considered used.</summary>
Access
=
1
,
/// <summary>Indicates implicit assignment to a member.</summary>
Assign
=
2
,
/// <summary>
/// Indicates implicit instantiation of a type with fixed constructor signature.
/// That means any unused constructor parameters won't be reported as such.
/// </summary>
InstantiatedWithFixedConstructorSignature
=
4
,
/// <summary>Indicates implicit instantiation of a type.</summary>
InstantiatedNoFixedConstructorSignature
=
8
,
}
/// <summary>
/// Specify what is considered used implicitly when marked
/// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>.
/// </summary>
[
Flags
]
public
enum
ImplicitUseTargetFlags
{
Default
=
Itself
,
Itself
=
1
,
/// <summary>Members of entity marked with attribute are considered used.</summary>
Members
=
2
,
/// <summary>Entity marked with attribute and all its members considered used.</summary>
WithMembers
=
Itself
|
Members
}
/// <summary>
/// This attribute is intended to mark publicly available API
/// which should not be removed and so is treated as used.
/// </summary>
[
MeansImplicitUse
(
ImplicitUseTargetFlags
.
WithMembers
)]
public
sealed
class
PublicAPIAttribute
:
Attribute
{
public
PublicAPIAttribute
()
{
}
public
PublicAPIAttribute
([
NotNull
]
string
comment
)
{
Comment
=
comment
;
}
[
CanBeNull
]
public
string
Comment
{
get
;
private
set
;
}
}
/// <summary>
/// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
/// If the parameter is a delegate, indicates that delegate is executed while the method is executed.
/// If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
InstantHandleAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that a method does not make any observable state changes.
/// The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
/// </summary>
/// <example><code>
/// [Pure] int Multiply(int x, int y) => x * y;
///
/// void M() {
/// Multiply(123, 42); // Waring: Return value of pure method is not used
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
PureAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that the return value of method invocation must be used.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
MustUseReturnValueAttribute
:
Attribute
{
public
MustUseReturnValueAttribute
()
{
}
public
MustUseReturnValueAttribute
([
NotNull
]
string
justification
)
{
Justification
=
justification
;
}
[
CanBeNull
]
public
string
Justification
{
get
;
private
set
;
}
}
/// <summary>
/// Indicates the type member or parameter of some type, that should be used instead of all other ways
/// to get the value that type. This annotation is useful when you have some "context" value evaluated
/// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
/// </summary>
/// <example><code>
/// class Foo {
/// [ProvidesContext] IBarService _barService = ...;
///
/// void ProcessNode(INode node) {
/// DoSomething(node, node.GetGlobalServices().Bar);
/// // ^ Warning: use value of '_barService' field
/// }
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Field
|
AttributeTargets
.
Property
|
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
|
AttributeTargets
.
Class
|
AttributeTargets
.
Interface
|
AttributeTargets
.
Struct
|
AttributeTargets
.
GenericParameter
)]
public
sealed
class
ProvidesContextAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that a parameter is a path to a file or a folder within a web project.
/// Path can be relative or absolute, starting from web root (~).
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
PathReferenceAttribute
:
Attribute
{
public
PathReferenceAttribute
()
{
}
public
PathReferenceAttribute
([
NotNull
,
PathReference
]
string
basePath
)
{
BasePath
=
basePath
;
}
[
CanBeNull
]
public
string
BasePath
{
get
;
private
set
;
}
}
/// <summary>
/// An extension method marked with this attribute is processed by ReSharper code completion
/// as a 'Source Template'. When extension method is completed over some expression, it's source code
/// is automatically expanded like a template at call site.
/// </summary>
/// <remarks>
/// Template method body can contain valid source code and/or special comments starting with '$'.
/// Text inside these comments is added as source code when the template is applied. Template parameters
/// can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
/// Use the <see cref="MacroAttribute"/> attribute to specify macros for parameters.
/// </remarks>
/// <example>
/// In this example, the 'forEach' method is a source template available over all values
/// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
/// <code>
/// [SourceTemplate]
/// public static void forEach<T>(this IEnumerable<T> xs) {
/// foreach (var x in xs) {
/// //$ $END$
/// }
/// }
/// </code>
/// </example>
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
SourceTemplateAttribute
:
Attribute
{
}
/// <summary>
/// Allows specifying a macro for a parameter of a <see cref="SourceTemplateAttribute">source template</see>.
/// </summary>
/// <remarks>
/// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
/// is defined in the <see cref="MacroAttribute.Expression"/> property. When applied on a method, the target
/// template parameter is defined in the <see cref="MacroAttribute.Target"/> property. To apply the macro silently
/// for the parameter, set the <see cref="MacroAttribute.Editable"/> property value = -1.
/// </remarks>
/// <example>
/// Applying the attribute on a source template method:
/// <code>
/// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
/// public static void forEach<T>(this IEnumerable<T> collection) {
/// foreach (var item in collection) {
/// //$ $END$
/// }
/// }
/// </code>
/// Applying the attribute on a template method parameter:
/// <code>
/// [SourceTemplate]
/// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
/// /*$ var $x$Id = "$newguid$" + x.ToString();
/// x.DoSomething($x$Id); */
/// }
/// </code>
/// </example>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
,
AllowMultiple
=
true
)]
public
sealed
class
MacroAttribute
:
Attribute
{
/// <summary>
/// Allows specifying a macro that will be executed for a <see cref="SourceTemplateAttribute">source template</see>
/// parameter when the template is expanded.
/// </summary>
[
CanBeNull
]
public
string
Expression
{
get
;
set
;
}
/// <summary>
/// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
/// </summary>
/// <remarks>
/// If the target parameter is used several times in the template, only one occurrence becomes editable;
/// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
/// use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
/// </remarks>>
public
int
Editable
{
get
;
set
;
}
/// <summary>
/// Identifies the target parameter of a <see cref="SourceTemplateAttribute">source template</see> if the
/// <see cref="MacroAttribute"/> is applied on a template method.
/// </summary>
[
CanBeNull
]
public
string
Target
{
get
;
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
,
AllowMultiple
=
true
)]
public
sealed
class
AspMvcAreaMasterLocationFormatAttribute
:
Attribute
{
public
AspMvcAreaMasterLocationFormatAttribute
([
NotNull
]
string
format
)
{
Format
=
format
;
}
[
NotNull
]
public
string
Format
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
,
AllowMultiple
=
true
)]
public
sealed
class
AspMvcAreaPartialViewLocationFormatAttribute
:
Attribute
{
public
AspMvcAreaPartialViewLocationFormatAttribute
([
NotNull
]
string
format
)
{
Format
=
format
;
}
[
NotNull
]
public
string
Format
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
,
AllowMultiple
=
true
)]
public
sealed
class
AspMvcAreaViewLocationFormatAttribute
:
Attribute
{
public
AspMvcAreaViewLocationFormatAttribute
([
NotNull
]
string
format
)
{
Format
=
format
;
}
[
NotNull
]
public
string
Format
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
,
AllowMultiple
=
true
)]
public
sealed
class
AspMvcMasterLocationFormatAttribute
:
Attribute
{
public
AspMvcMasterLocationFormatAttribute
([
NotNull
]
string
format
)
{
Format
=
format
;
}
[
NotNull
]
public
string
Format
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
,
AllowMultiple
=
true
)]
public
sealed
class
AspMvcPartialViewLocationFormatAttribute
:
Attribute
{
public
AspMvcPartialViewLocationFormatAttribute
([
NotNull
]
string
format
)
{
Format
=
format
;
}
[
NotNull
]
public
string
Format
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
,
AllowMultiple
=
true
)]
public
sealed
class
AspMvcViewLocationFormatAttribute
:
Attribute
{
public
AspMvcViewLocationFormatAttribute
([
NotNull
]
string
format
)
{
Format
=
format
;
}
[
NotNull
]
public
string
Format
{
get
;
private
set
;
}
}
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
/// is an MVC action. If applied to a method, the MVC action name is calculated
/// implicitly from the context. Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
)]
public
sealed
class
AspMvcActionAttribute
:
Attribute
{
public
AspMvcActionAttribute
()
{
}
public
AspMvcActionAttribute
([
NotNull
]
string
anonymousProperty
)
{
AnonymousProperty
=
anonymousProperty
;
}
[
CanBeNull
]
public
string
AnonymousProperty
{
get
;
private
set
;
}
}
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC area.
/// Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcAreaAttribute
:
Attribute
{
public
AspMvcAreaAttribute
()
{
}
public
AspMvcAreaAttribute
([
NotNull
]
string
anonymousProperty
)
{
AnonymousProperty
=
anonymousProperty
;
}
[
CanBeNull
]
public
string
AnonymousProperty
{
get
;
private
set
;
}
}
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
/// an MVC controller. If applied to a method, the MVC controller name is calculated
/// implicitly from the context. Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
)]
public
sealed
class
AspMvcControllerAttribute
:
Attribute
{
public
AspMvcControllerAttribute
()
{
}
public
AspMvcControllerAttribute
([
NotNull
]
string
anonymousProperty
)
{
AnonymousProperty
=
anonymousProperty
;
}
[
CanBeNull
]
public
string
AnonymousProperty
{
get
;
private
set
;
}
}
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute
/// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcMasterAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute
/// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcModelTypeAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
/// partial view. If applied to a method, the MVC partial view name is calculated implicitly
/// from the context. Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
)]
public
sealed
class
AspMvcPartialViewAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Class
|
AttributeTargets
.
Method
)]
public
sealed
class
AspMvcSuppressViewErrorAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
/// Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcDisplayTemplateAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template.
/// Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcEditorTemplateAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC template.
/// Use this attribute for custom wrappers similar to
/// <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcTemplateAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
/// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
/// from the context. Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Controller.View(Object)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
)]
public
sealed
class
AspMvcViewAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
/// is an MVC view component name.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AspMvcViewComponentAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
/// is an MVC view component view. If applied to a method, the MVC view component view name is default.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
)]
public
sealed
class
AspMvcViewComponentViewAttribute
:
Attribute
{
}
/// <summary>
/// ASP.NET MVC attribute. When applied to a parameter of an attribute,
/// indicates that this parameter is an MVC action name.
/// </summary>
/// <example><code>
/// [ActionName("Foo")]
/// public ActionResult Login(string returnUrl) {
/// ViewBag.ReturnUrl = Url.Action("Foo"); // OK
/// return RedirectToAction("Bar"); // Error: Cannot resolve action
/// }
/// </code></example>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
)]
public
sealed
class
AspMvcActionSelectorAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Property
|
AttributeTargets
.
Field
)]
public
sealed
class
HtmlElementAttributesAttribute
:
Attribute
{
public
HtmlElementAttributesAttribute
()
{
}
public
HtmlElementAttributesAttribute
([
NotNull
]
string
name
)
{
Name
=
name
;
}
[
CanBeNull
]
public
string
Name
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Field
|
AttributeTargets
.
Property
)]
public
sealed
class
HtmlAttributeValueAttribute
:
Attribute
{
public
HtmlAttributeValueAttribute
([
NotNull
]
string
name
)
{
Name
=
name
;
}
[
NotNull
]
public
string
Name
{
get
;
private
set
;
}
}
/// <summary>
/// Razor attribute. Indicates that a parameter or a method is a Razor section.
/// Use this attribute for custom wrappers similar to
/// <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
|
AttributeTargets
.
Method
)]
public
sealed
class
RazorSectionAttribute
:
Attribute
{
}
/// <summary>
/// Indicates how method, constructor invocation or property access
/// over collection type affects content of the collection.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Method
|
AttributeTargets
.
Constructor
|
AttributeTargets
.
Property
)]
public
sealed
class
CollectionAccessAttribute
:
Attribute
{
public
CollectionAccessAttribute
(
CollectionAccessType
collectionAccessType
)
{
CollectionAccessType
=
collectionAccessType
;
}
public
CollectionAccessType
CollectionAccessType
{
get
;
private
set
;
}
}
[
Flags
]
public
enum
CollectionAccessType
{
/// <summary>Method does not use or modify content of the collection.</summary>
None
=
0
,
/// <summary>Method only reads content of the collection but does not modify it.</summary>
Read
=
1
,
/// <summary>Method can change content of the collection but does not add new elements.</summary>
ModifyExistingContent
=
2
,
/// <summary>Method can add new elements to the collection.</summary>
UpdatedContent
=
ModifyExistingContent
|
4
}
/// <summary>
/// Indicates that the marked method is assertion method, i.e. it halts control flow if
/// one of the conditions is satisfied. To set the condition, mark one of the parameters with
/// <see cref="AssertionConditionAttribute"/> attribute.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
AssertionMethodAttribute
:
Attribute
{
}
/// <summary>
/// Indicates the condition parameter of the assertion method. The method itself should be
/// marked by <see cref="AssertionMethodAttribute"/> attribute. The mandatory argument of
/// the attribute is the assertion type.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
AssertionConditionAttribute
:
Attribute
{
public
AssertionConditionAttribute
(
AssertionConditionType
conditionType
)
{
ConditionType
=
conditionType
;
}
public
AssertionConditionType
ConditionType
{
get
;
private
set
;
}
}
/// <summary>
/// Specifies assertion type. If the assertion method argument satisfies the condition,
/// then the execution continues. Otherwise, execution is assumed to be halted.
/// </summary>
public
enum
AssertionConditionType
{
/// <summary>Marked parameter should be evaluated to true.</summary>
IS_TRUE
=
0
,
/// <summary>Marked parameter should be evaluated to false.</summary>
IS_FALSE
=
1
,
/// <summary>Marked parameter should be evaluated to null value.</summary>
IS_NULL
=
2
,
/// <summary>Marked parameter should be evaluated to not null value.</summary>
IS_NOT_NULL
=
3
,
}
/// <summary>
/// Indicates that the marked method unconditionally terminates control flow execution.
/// For example, it could unconditionally throw exception.
/// </summary>
[
Obsolete
(
"Use [ContractAnnotation('=> halt')] instead"
)]
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
TerminatesProgramAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
/// .Where). This annotation allows inference of [InstantHandle] annotation for parameters
/// of delegate type by analyzing LINQ method chains.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
LinqTunnelAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that IEnumerable, passed as parameter, is not enumerated.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
NoEnumerationAttribute
:
Attribute
{
}
/// <summary>
/// Indicates that parameter is regular expression pattern.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
RegexPatternAttribute
:
Attribute
{
}
/// <summary>
/// Prevents the Member Reordering feature from tossing members of the marked class.
/// </summary>
/// <remarks>
/// The attribute must be mentioned in your member reordering patterns
/// </remarks>
[
AttributeUsage
(
AttributeTargets
.
Class
|
AttributeTargets
.
Interface
|
AttributeTargets
.
Struct
|
AttributeTargets
.
Enum
)]
public
sealed
class
NoReorderAttribute
:
Attribute
{
}
/// <summary>
/// XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
/// as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
/// </summary>
[
AttributeUsage
(
AttributeTargets
.
Class
)]
public
sealed
class
XamlItemsControlAttribute
:
Attribute
{
}
/// <summary>
/// XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
/// is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
/// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
/// </summary>
/// <remarks>
/// Property should have the tree ancestor of the <c>ItemsControl</c> type or
/// marked with the <see cref="XamlItemsControlAttribute"/> attribute.
/// </remarks>
[
AttributeUsage
(
AttributeTargets
.
Property
)]
public
sealed
class
XamlItemBindingOfItemsControlAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Class
,
AllowMultiple
=
true
)]
public
sealed
class
AspChildControlTypeAttribute
:
Attribute
{
public
AspChildControlTypeAttribute
([
NotNull
]
string
tagName
,
[
NotNull
]
Type
controlType
)
{
TagName
=
tagName
;
ControlType
=
controlType
;
}
[
NotNull
]
public
string
TagName
{
get
;
private
set
;
}
[
NotNull
]
public
Type
ControlType
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Property
|
AttributeTargets
.
Method
)]
public
sealed
class
AspDataFieldAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Property
|
AttributeTargets
.
Method
)]
public
sealed
class
AspDataFieldsAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Property
)]
public
sealed
class
AspMethodPropertyAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Class
,
AllowMultiple
=
true
)]
public
sealed
class
AspRequiredAttributeAttribute
:
Attribute
{
public
AspRequiredAttributeAttribute
([
NotNull
]
string
attribute
)
{
Attribute
=
attribute
;
}
[
NotNull
]
public
string
Attribute
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Property
)]
public
sealed
class
AspTypePropertyAttribute
:
Attribute
{
public
bool
CreateConstructorReferences
{
get
;
private
set
;
}
public
AspTypePropertyAttribute
(
bool
createConstructorReferences
)
{
CreateConstructorReferences
=
createConstructorReferences
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
,
AllowMultiple
=
true
)]
public
sealed
class
RazorImportNamespaceAttribute
:
Attribute
{
public
RazorImportNamespaceAttribute
([
NotNull
]
string
name
)
{
Name
=
name
;
}
[
NotNull
]
public
string
Name
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
,
AllowMultiple
=
true
)]
public
sealed
class
RazorInjectionAttribute
:
Attribute
{
public
RazorInjectionAttribute
([
NotNull
]
string
type
,
[
NotNull
]
string
fieldName
)
{
Type
=
type
;
FieldName
=
fieldName
;
}
[
NotNull
]
public
string
Type
{
get
;
private
set
;
}
[
NotNull
]
public
string
FieldName
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Assembly
,
AllowMultiple
=
true
)]
public
sealed
class
RazorDirectiveAttribute
:
Attribute
{
public
RazorDirectiveAttribute
([
NotNull
]
string
directive
)
{
Directive
=
directive
;
}
[
NotNull
]
public
string
Directive
{
get
;
private
set
;
}
}
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
RazorHelperCommonAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Property
)]
public
sealed
class
RazorLayoutAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
RazorWriteLiteralMethodAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Method
)]
public
sealed
class
RazorWriteMethodAttribute
:
Attribute
{
}
[
AttributeUsage
(
AttributeTargets
.
Parameter
)]
public
sealed
class
RazorWriteMethodParameterAttribute
:
Attribute
{
}
}
\ No newline at end of file
Examples/Titanium.Web.Proxy.Examples.Wpf/Properties/AssemblyInfo.cs
0 → 100644
View file @
64ce8071
using
System.Reflection
;
using
System.Resources
;
using
System.Runtime.CompilerServices
;
using
System.Runtime.InteropServices
;
using
System.Windows
;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Demo WPF")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Demo WPF")]
[assembly: AssemblyCopyright("Copyright ©2017 Titanium")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
//In order to begin building localizable applications, set
//<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
//inside a <PropertyGroup>. For example, if you are using US english
//in your source files, set the <UICulture> to en-US. Then uncomment
//the NeutralResourceLanguage attribute below. Update the "en-US" in
//the line below to match the UICulture setting in the project file.
//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
[
assembly
:
ThemeInfo
(
ResourceDictionaryLocation
.
None
,
//where theme specific resource dictionaries are located
//(used if a resource is not found in the page,
// or application resource dictionaries)
ResourceDictionaryLocation
.
SourceAssembly
//where the generic resource dictionary is located
//(used if a resource is not found in the page,
// app, or any theme specific resource dictionaries)
)]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
Examples/Titanium.Web.Proxy.Examples.Wpf/Properties/Resources.Designer.cs
0 → 100644
View file @
64ce8071
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace
Titanium.Web.Proxy.Examples.Wpf.Properties
{
using
System
;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[
global
::
System
.
CodeDom
.
Compiler
.
GeneratedCodeAttribute
(
"System.Resources.Tools.StronglyTypedResourceBuilder"
,
"4.0.0.0"
)]
[
global
::
System
.
Diagnostics
.
DebuggerNonUserCodeAttribute
()]
[
global
::
System
.
Runtime
.
CompilerServices
.
CompilerGeneratedAttribute
()]
internal
class
Resources
{
private
static
global
::
System
.
Resources
.
ResourceManager
resourceMan
;
private
static
global
::
System
.
Globalization
.
CultureInfo
resourceCulture
;
[
global
::
System
.
Diagnostics
.
CodeAnalysis
.
SuppressMessageAttribute
(
"Microsoft.Performance"
,
"CA1811:AvoidUncalledPrivateCode"
)]
internal
Resources
()
{
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[
global
::
System
.
ComponentModel
.
EditorBrowsableAttribute
(
global
::
System
.
ComponentModel
.
EditorBrowsableState
.
Advanced
)]
internal
static
global
::
System
.
Resources
.
ResourceManager
ResourceManager
{
get
{
if
(
object
.
ReferenceEquals
(
resourceMan
,
null
))
{
global
::
System
.
Resources
.
ResourceManager
temp
=
new
global
::
System
.
Resources
.
ResourceManager
(
"Titanium.Web.Proxy.Examples.Wpf.Properties.Resources"
,
typeof
(
Resources
).
Assembly
);
resourceMan
=
temp
;
}
return
resourceMan
;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[
global
::
System
.
ComponentModel
.
EditorBrowsableAttribute
(
global
::
System
.
ComponentModel
.
EditorBrowsableState
.
Advanced
)]
internal
static
global
::
System
.
Globalization
.
CultureInfo
Culture
{
get
{
return
resourceCulture
;
}
set
{
resourceCulture
=
value
;
}
}
}
}
Examples/Titanium.Web.Proxy.Examples.Wpf/Properties/Resources.resx
0 → 100644
View file @
64ce8071
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema
id=
"root"
xmlns=
""
xmlns:xsd=
"http://www.w3.org/2001/XMLSchema"
xmlns:msdata=
"urn:schemas-microsoft-com:xml-msdata"
>
<xsd:element
name=
"root"
msdata:IsDataSet=
"true"
>
<xsd:complexType>
<xsd:choice
maxOccurs=
"unbounded"
>
<xsd:element
name=
"metadata"
>
<xsd:complexType>
<xsd:sequence>
<xsd:element
name=
"value"
type=
"xsd:string"
minOccurs=
"0"
/>
</xsd:sequence>
<xsd:attribute
name=
"name"
type=
"xsd:string"
/>
<xsd:attribute
name=
"type"
type=
"xsd:string"
/>
<xsd:attribute
name=
"mimetype"
type=
"xsd:string"
/>
</xsd:complexType>
</xsd:element>
<xsd:element
name=
"assembly"
>
<xsd:complexType>
<xsd:attribute
name=
"alias"
type=
"xsd:string"
/>
<xsd:attribute
name=
"name"
type=
"xsd:string"
/>
</xsd:complexType>
</xsd:element>
<xsd:element
name=
"data"
>
<xsd:complexType>
<xsd:sequence>
<xsd:element
name=
"value"
type=
"xsd:string"
minOccurs=
"0"
msdata:Ordinal=
"1"
/>
<xsd:element
name=
"comment"
type=
"xsd:string"
minOccurs=
"0"
msdata:Ordinal=
"2"
/>
</xsd:sequence>
<xsd:attribute
name=
"name"
type=
"xsd:string"
msdata:Ordinal=
"1"
/>
<xsd:attribute
name=
"type"
type=
"xsd:string"
msdata:Ordinal=
"3"
/>
<xsd:attribute
name=
"mimetype"
type=
"xsd:string"
msdata:Ordinal=
"4"
/>
</xsd:complexType>
</xsd:element>
<xsd:element
name=
"resheader"
>
<xsd:complexType>
<xsd:sequence>
<xsd:element
name=
"value"
type=
"xsd:string"
minOccurs=
"0"
msdata:Ordinal=
"1"
/>
</xsd:sequence>
<xsd:attribute
name=
"name"
type=
"xsd:string"
use=
"required"
/>
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader
name=
"resmimetype"
>
<value>
text/microsoft-resx
</value>
</resheader>
<resheader
name=
"version"
>
<value>
2.0
</value>
</resheader>
<resheader
name=
"reader"
>
<value>
System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
</value>
</resheader>
<resheader
name=
"writer"
>
<value>
System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
</value>
</resheader>
</root>
\ No newline at end of file
Examples/Titanium.Web.Proxy.Examples.Wpf/Properties/Settings.Designer.cs
0 → 100644
View file @
64ce8071
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace
Titanium.Web.Proxy.Examples.Wpf.Properties
{
[
global
::
System
.
Runtime
.
CompilerServices
.
CompilerGeneratedAttribute
()]
[
global
::
System
.
CodeDom
.
Compiler
.
GeneratedCodeAttribute
(
"Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator"
,
"15.1.0.0"
)]
internal
sealed
partial
class
Settings
:
global
::
System
.
Configuration
.
ApplicationSettingsBase
{
private
static
Settings
defaultInstance
=
((
Settings
)(
global
::
System
.
Configuration
.
ApplicationSettingsBase
.
Synchronized
(
new
Settings
())));
public
static
Settings
Default
{
get
{
return
defaultInstance
;
}
}
}
}
Examples/Titanium.Web.Proxy.Examples.Wpf/Properties/Settings.settings
0 → 100644
View file @
64ce8071
<?xml version='1.0' encoding='utf-8'?>
<SettingsFile
xmlns=
"uri:settings"
CurrentProfile=
"(Default)"
>
<Profiles>
<Profile
Name=
"(Default)"
/>
</Profiles>
<Settings
/>
</SettingsFile>
\ No newline at end of file
Examples/Titanium.Web.Proxy.Examples.Wpf/SessionListItem.cs
0 → 100644
View file @
64ce8071
using
System
;
using
System.Collections.Generic
;
using
System.ComponentModel
;
using
System.Linq
;
using
System.Runtime.CompilerServices
;
using
System.Text
;
using
System.Threading.Tasks
;
using
Titanium.Web.Proxy.EventArguments
;
using
Titanium.Web.Proxy.Examples.Wpf.Annotations
;
namespace
Titanium.Web.Proxy.Examples.Wpf
{
public
class
SessionListItem
:
INotifyPropertyChanged
{
private
string
statusCode
;
private
string
protocol
;
private
string
host
;
private
string
url
;
private
long
bodySize
;
private
string
process
;
private
long
receivedDataCount
;
private
long
sentDataCount
;
public
int
Number
{
get
;
set
;
}
public
SessionEventArgs
SessionArgs
{
get
;
set
;
}
public
string
StatusCode
{
get
{
return
statusCode
;
}
set
{
SetField
(
ref
statusCode
,
value
);}
}
public
string
Protocol
{
get
{
return
protocol
;
}
set
{
SetField
(
ref
protocol
,
value
);
}
}
public
string
Host
{
get
{
return
host
;
}
set
{
SetField
(
ref
host
,
value
);
}
}
public
string
Url
{
get
{
return
url
;
}
set
{
SetField
(
ref
url
,
value
);
}
}
public
long
BodySize
{
get
{
return
bodySize
;
}
set
{
SetField
(
ref
bodySize
,
value
);
}
}
public
string
Process
{
get
{
return
process
;
}
set
{
SetField
(
ref
process
,
value
);
}
}
public
long
ReceivedDataCount
{
get
{
return
receivedDataCount
;
}
set
{
SetField
(
ref
receivedDataCount
,
value
);
}
}
public
long
SentDataCount
{
get
{
return
sentDataCount
;
}
set
{
SetField
(
ref
sentDataCount
,
value
);
}
}
public
event
PropertyChangedEventHandler
PropertyChanged
;
protected
void
SetField
<
T
>(
ref
T
field
,
T
value
,[
CallerMemberName
]
string
propertyName
=
null
)
{
field
=
value
;
OnPropertyChanged
(
propertyName
);
}
[
NotifyPropertyChangedInvocator
]
protected
virtual
void
OnPropertyChanged
([
CallerMemberName
]
string
propertyName
=
null
)
{
PropertyChanged
?.
Invoke
(
this
,
new
PropertyChangedEventArgs
(
propertyName
));
}
public
void
Update
()
{
var
request
=
SessionArgs
.
WebSession
.
Request
;
var
response
=
SessionArgs
.
WebSession
.
Response
;
StatusCode
=
response
?.
ResponseStatusCode
??
"-"
;
Protocol
=
request
.
RequestUri
.
Scheme
;
if
(
SessionArgs
is
TunnelConnectSessionEventArgs
)
{
Host
=
"Tunnel to"
;
Url
=
request
.
RequestUri
.
Host
+
":"
+
request
.
RequestUri
.
Port
;
}
else
{
Host
=
request
.
RequestUri
.
Host
;
Url
=
request
.
RequestUri
.
AbsolutePath
;
}
BodySize
=
response
?.
ContentLength
??
-
1
;
Process
=
GetProcessDescription
(
SessionArgs
.
WebSession
.
ProcessId
.
Value
);
}
private
string
GetProcessDescription
(
int
processId
)
{
try
{
var
process
=
System
.
Diagnostics
.
Process
.
GetProcessById
(
processId
);
return
process
.
ProcessName
+
":"
+
processId
;
}
catch
(
Exception
)
{
return
string
.
Empty
;
}
}
}
}
Examples/Titanium.Web.Proxy.Examples.Wpf/Titanium.Web.Proxy.Examples.Wpf.csproj
0 → 100644
View file @
64ce8071
<?xml version="1.0" encoding="utf-8"?>
<Project
ToolsVersion=
"15.0"
xmlns=
"http://schemas.microsoft.com/developer/msbuild/2003"
>
<Import
Project=
"$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"
Condition=
"Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"
/>
<PropertyGroup>
<Configuration
Condition=
" '$(Configuration)' == '' "
>
Debug
</Configuration>
<Platform
Condition=
" '$(Platform)' == '' "
>
AnyCPU
</Platform>
<ProjectGuid>
{4406CE17-9A39-4F28-8363-6169A4F799C1}
</ProjectGuid>
<OutputType>
WinExe
</OutputType>
<RootNamespace>
Titanium.Web.Proxy.Examples.Wpf
</RootNamespace>
<AssemblyName>
Titanium.Web.Proxy.Examples.Wpf
</AssemblyName>
<TargetFrameworkVersion>
v4.5
</TargetFrameworkVersion>
<FileAlignment>
512
</FileAlignment>
<ProjectTypeGuids>
{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
</ProjectTypeGuids>
<WarningLevel>
4
</WarningLevel>
<AutoGenerateBindingRedirects>
true
</AutoGenerateBindingRedirects>
<TargetFrameworkProfile
/>
<PublishUrl>
publish\
</PublishUrl>
<Install>
true
</Install>
<InstallFrom>
Disk
</InstallFrom>
<UpdateEnabled>
false
</UpdateEnabled>
<UpdateMode>
Foreground
</UpdateMode>
<UpdateInterval>
7
</UpdateInterval>
<UpdateIntervalUnits>
Days
</UpdateIntervalUnits>
<UpdatePeriodically>
false
</UpdatePeriodically>
<UpdateRequired>
false
</UpdateRequired>
<MapFileExtensions>
true
</MapFileExtensions>
<ApplicationRevision>
0
</ApplicationRevision>
<ApplicationVersion>
1.0.0.%2a
</ApplicationVersion>
<IsWebBootstrapper>
false
</IsWebBootstrapper>
<UseApplicationTrust>
false
</UseApplicationTrust>
<BootstrapperEnabled>
true
</BootstrapperEnabled>
</PropertyGroup>
<PropertyGroup
Condition=
" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "
>
<PlatformTarget>
AnyCPU
</PlatformTarget>
<DebugSymbols>
true
</DebugSymbols>
<DebugType>
full
</DebugType>
<Optimize>
false
</Optimize>
<OutputPath>
bin\Debug\
</OutputPath>
<DefineConstants>
DEBUG;TRACE
</DefineConstants>
<ErrorReport>
prompt
</ErrorReport>
<WarningLevel>
4
</WarningLevel>
<LangVersion>
6
</LangVersion>
</PropertyGroup>
<PropertyGroup
Condition=
" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "
>
<PlatformTarget>
AnyCPU
</PlatformTarget>
<DebugType>
pdbonly
</DebugType>
<Optimize>
true
</Optimize>
<OutputPath>
bin\Release\
</OutputPath>
<DefineConstants>
TRACE
</DefineConstants>
<ErrorReport>
prompt
</ErrorReport>
<WarningLevel>
4
</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference
Include=
"System"
/>
<Reference
Include=
"System.Data"
/>
<Reference
Include=
"System.Xml"
/>
<Reference
Include=
"Microsoft.CSharp"
/>
<Reference
Include=
"System.Core"
/>
<Reference
Include=
"System.Xml.Linq"
/>
<Reference
Include=
"System.Data.DataSetExtensions"
/>
<Reference
Include=
"System.Net.Http"
/>
<Reference
Include=
"System.Xaml"
>
<RequiredTargetFramework>
4.0
</RequiredTargetFramework>
</Reference>
<Reference
Include=
"WindowsBase"
/>
<Reference
Include=
"PresentationCore"
/>
<Reference
Include=
"PresentationFramework"
/>
</ItemGroup>
<ItemGroup>
<ApplicationDefinition
Include=
"App.xaml"
>
<Generator>
MSBuild:Compile
</Generator>
<SubType>
Designer
</SubType>
</ApplicationDefinition>
<Compile
Include=
"Properties\Annotations.cs"
/>
<Compile
Include=
"SessionListItem.cs"
/>
<Page
Include=
"MainWindow.xaml"
>
<Generator>
MSBuild:Compile
</Generator>
<SubType>
Designer
</SubType>
</Page>
<Compile
Include=
"App.xaml.cs"
>
<DependentUpon>
App.xaml
</DependentUpon>
<SubType>
Code
</SubType>
</Compile>
<Compile
Include=
"MainWindow.xaml.cs"
>
<DependentUpon>
MainWindow.xaml
</DependentUpon>
<SubType>
Code
</SubType>
</Compile>
</ItemGroup>
<ItemGroup>
<Compile
Include=
"Properties\AssemblyInfo.cs"
>
<SubType>
Code
</SubType>
</Compile>
<Compile
Include=
"Properties\Resources.Designer.cs"
>
<AutoGen>
True
</AutoGen>
<DesignTime>
True
</DesignTime>
<DependentUpon>
Resources.resx
</DependentUpon>
</Compile>
<Compile
Include=
"Properties\Settings.Designer.cs"
>
<AutoGen>
True
</AutoGen>
<DependentUpon>
Settings.settings
</DependentUpon>
<DesignTimeSharedInput>
True
</DesignTimeSharedInput>
</Compile>
<EmbeddedResource
Include=
"Properties\Resources.resx"
>
<Generator>
ResXFileCodeGenerator
</Generator>
<LastGenOutput>
Resources.Designer.cs
</LastGenOutput>
</EmbeddedResource>
<None
Include=
"Properties\Settings.settings"
>
<Generator>
SettingsSingleFileGenerator
</Generator>
<LastGenOutput>
Settings.Designer.cs
</LastGenOutput>
</None>
</ItemGroup>
<ItemGroup>
<None
Include=
"App.config"
/>
</ItemGroup>
<ItemGroup>
<ProjectReference
Include=
"..\..\Titanium.Web.Proxy\Titanium.Web.Proxy.csproj"
>
<Project>
{8d73a1be-868c-42d2-9ece-f32cc1a02906}
</Project>
<Name>
Titanium.Web.Proxy
</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<BootstrapperPackage
Include=
"Microsoft.Net.Framework.3.5.SP1"
>
<Visible>
False
</Visible>
<ProductName>
.NET Framework 3.5 SP1
</ProductName>
<Install>
false
</Install>
</BootstrapperPackage>
</ItemGroup>
<Import
Project=
"$(MSBuildToolsPath)\Microsoft.CSharp.targets"
/>
</Project>
\ No newline at end of file
Titanium.Web.Proxy.sln
View file @
64ce8071
...
@@ -35,6 +35,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.Web.Proxy.UnitTest
...
@@ -35,6 +35,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.Web.Proxy.UnitTest
EndProject
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.Web.Proxy.IntegrationTests", "Tests\Titanium.Web.Proxy.IntegrationTests\Titanium.Web.Proxy.IntegrationTests.csproj", "{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.Web.Proxy.IntegrationTests", "Tests\Titanium.Web.Proxy.IntegrationTests\Titanium.Web.Proxy.IntegrationTests.csproj", "{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}"
EndProject
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.Web.Proxy.Examples.Wpf", "Examples\Titanium.Web.Proxy.Examples.Wpf\Titanium.Web.Proxy.Examples.Wpf.csproj", "{4406CE17-9A39-4F28-8363-6169A4F799C1}"
EndProject
Global
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|Any CPU = Debug|Any CPU
...
@@ -57,6 +59,10 @@ Global
...
@@ -57,6 +59,10 @@ Global
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}.Debug|Any CPU.Build.0 = Debug|Any CPU
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}.Debug|Any CPU.Build.0 = Debug|Any CPU
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}.Release|Any CPU.ActiveCfg = Release|Any CPU
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}.Release|Any CPU.ActiveCfg = Release|Any CPU
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}.Release|Any CPU.Build.0 = Release|Any CPU
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16}.Release|Any CPU.Build.0 = Release|Any CPU
{4406CE17-9A39-4F28-8363-6169A4F799C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{4406CE17-9A39-4F28-8363-6169A4F799C1}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4406CE17-9A39-4F28-8363-6169A4F799C1}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4406CE17-9A39-4F28-8363-6169A4F799C1}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
HideSolutionNode = FALSE
...
@@ -65,6 +71,7 @@ Global
...
@@ -65,6 +71,7 @@ Global
{F3B7E553-1904-4E80-BDC7-212342B5C952} = {B6DBABDC-C985-4872-9C38-B4E5079CBC4B}
{F3B7E553-1904-4E80-BDC7-212342B5C952} = {B6DBABDC-C985-4872-9C38-B4E5079CBC4B}
{B517E3D0-D03B-436F-AB03-34BA0D5321AF} = {BC1E0789-D348-49CF-8B67-5E99D50EDF64}
{B517E3D0-D03B-436F-AB03-34BA0D5321AF} = {BC1E0789-D348-49CF-8B67-5E99D50EDF64}
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16} = {BC1E0789-D348-49CF-8B67-5E99D50EDF64}
{32231301-B0FB-4F9E-98DF-B3E8A88F4C16} = {BC1E0789-D348-49CF-8B67-5E99D50EDF64}
{4406CE17-9A39-4F28-8363-6169A4F799C1} = {B6DBABDC-C985-4872-9C38-B4E5079CBC4B}
EndGlobalSection
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
GlobalSection(ExtensibilityGlobals) = postSolution
EnterpriseLibraryConfigurationToolBinariesPath = .1.505.2\lib\NET35
EnterpriseLibraryConfigurationToolBinariesPath = .1.505.2\lib\NET35
...
...
Titanium.Web.Proxy.sln.DotSettings
View file @
64ce8071
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:Boolean x:Key="/Default/CodeInspection/CodeAnnotations/NamespacesWithAnnotations/=Titanium_002EWeb_002EProxy_002EExamples_002EWpf_002EAnnotations/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/LINE_FEED_AT_FILE_END/@EntryValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/LINE_FEED_AT_FILE_END/@EntryValue">True</s:Boolean>
<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_CASE_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_CASE_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_EMBEDDED_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_EMBEDDED_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment