public class Foo
{
    [UsedImplicitly]
    public Foo()
    {
        //反射调用
    }

    public Foo(string str)
    {
        //被引用
    }
}

var uri1 = new Uri("https://blog.lindexi.com/post/123");
var uri2 = "/api/12";

    if (Uri.TryCreate(uri1, uri2, out var absoluteUrl))
    {
        // 拼接成功，在这里就可以使用 absoluteUrl 拼接后的绝对路径
    }

            var uriBuilder = new UriBuilder(new Uri("http://blog.lindexi.com"));
            NameValueCollection query = HttpUtility.ParseQueryString(uriBuilder.Query);
            query["Foo"] = "123";
            query["doubi"] = "doubi";
            uriBuilder.Query = query.ToString();

            Console.WriteLine(uriBuilder.Uri);

var streamResourceInfo = Application.GetResourceStream(new Uri("pack://application:,,,/ResourceFile.xaml"))

var streamResourceInfo = Application.GetContentStream(new Uri("pack://application:,,,/ResourceFile.xaml"))

static bool IsAsciiLetterOrDigit(char character) =>
    ((((uint) (character - 'A')) & ~0x20) < 26) ||
    (((uint) (character - '0')) < 10);

Convert.ToString(value, 2)

<Button ToolTipService.ShowOnDisabled="True">  

System.Windows.Forms.Screen.AllScreens

var screenCount = Screen.AllScreens.Length;

using System.Security.Principal;

// 其他代码

            WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent();
            string crentUserAd = windowsIdentity.Name;

System.Windows.Markup.XamlParseException 

在 System.Windows.Markup.StaticExtension 上提供值xxx

无法将 xx.Properties.Resources.xx  StaticExtension 值解析为枚举、静态字段或静态属性

using System.Security.Principal;

        public static bool IsAdministrator()
        {
            WindowsIdentity current = WindowsIdentity.GetCurrent();
            WindowsPrincipal windowsPrincipal = new WindowsPrincipal(current);
            //WindowsBuiltInRole可以枚举出很多权限，例如系统用户、User、Guest等等
            return windowsPrincipal.IsInRole(WindowsBuiltInRole.Administrator);
        }

EventManager.RegisterClassHandler(typeof(TextBox), TextBox.KeyDownEvent, new RoutedEventHandler(方法));

<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup useLegacyV2RuntimeActivationPolicy="true">
  <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>
</configuration>

    private static void Func(){}
    public void C()
    {
        c(Func);
    }

    private static void Func(){}
    public void C()
    {
         var temp = new delegate(){ Func };
         c(temp);
    }

    private static void Func(){}
    private delegate Temp { get; } = new delegate(){Func};
    private void C()
    {
        c(Temp);
    }

    <SolidColorBrush x:Key="LikeGreen">
        <SolidColorBrush.Color>
            <Color R="100" G="200" B="30" A="100"/>
        </SolidColorBrush.Color>
    </SolidColorBrush>

    file.Attributes.HasFlag(FileAttributes.Hidden)

element.RaiseEvent(new MouseEventArgs(Mouse.PrimaryDevice, 1)
            {
                RoutedEvent = Mouse.MouseDownEvent
            });

{Binding MyCollection[foo bar]}

{Binding MyCollection[[foo&x20;bar]]}

            Task.Delay(TimeSpan.FromSeconds(5)).ContinueWith
            (
                _ => Foo()
                // 如果 Foo 不需要在主线程，请注释下面一段代码
                , TaskScheduler.FromCurrentSynchronizationContext()
            );

ResizeMode="NoResize"

var caretWidth = SystemParameters.CaretWidth;

           var fontFamily = new FontFamily("宋体");
           Typeface typeface = new Typeface(fontFamily, FontStyles.Normal, FontWeights.Normal, FontStretches.Normal);

           var formattedText = new FormattedText("林", CultureInfo.CurrentCulture, FlowDirection.LeftToRight, typeface, 20, Brushes.Black, new NumberSubstitution(), TextFormattingMode.Ideal, 96);
           var geometry = formattedText.BuildGeometry(new Point());
           Path.Data = geometry;

           // 如果要拆开的话的例子
           if (geometry is GeometryGroup geometryGroup)
           {
               foreach (var geometryGroupChild in geometryGroup.Children)
               {
                   if (geometryGroupChild is GeometryGroup subGeometryGroup)
                   {
                       foreach (var child in subGeometryGroup.Children)
                       {
                           if (child is PathGeometry pathGeometry)
                           {
                               foreach (var pathGeometryFigure in pathGeometry.Figures)
                               {
                               }
                           }
                       }
                   }
               }
           }

SystemParameters.WorkArea

window.Activate();

        public static readonly RoutedEvent LindexiEvent = EventManager.RegisterRoutedEvent("Lindexi",
            RoutingStrategy.Bubble, typeof(EventHandler<LindexiRoutedEventArgs>), typeof(Owner));

        public event EventHandler<LindexiRoutedEventArgs> Lindexi
        {
            add { AddHandler(LindexiEvent, value); }
            remove { RemoveHandler(LindexiEvent, value); }
        }

    public class Owner : UIElement
    {
        public static readonly RoutedEvent LindexiEvent = EventManager.RegisterRoutedEvent("Lindexi",
            RoutingStrategy.Bubble, typeof(LindexiRoutedEventEventHandler), typeof(Owner));

        public event LindexiRoutedEventEventHandler Lindexi
        {
            add { AddHandler(LindexiEvent, value); }
            remove { RemoveHandler(LindexiEvent, value); }
        }

        public void RaiseLindexiEvent()
        {
            RaiseEvent(new LindexiRoutedEventArgs(LindexiEvent, this));
        }
    }

    public class LindexiRoutedEventArgs : RoutedEventArgs
    {
        /// <inheritdoc />
        public LindexiRoutedEventArgs()
        {
        }

        /// <inheritdoc />
        public LindexiRoutedEventArgs(RoutedEvent routedEvent) : base(routedEvent)
        {
        }

        /// <inheritdoc />
        public LindexiRoutedEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source)
        {
        }

        protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        {
            // 这个方法的重写是可选的，用途是为了提升性能
            // 如无重写，底层将会调用 Delegate.DynamicInvoke 方法触发事件，这是通过反射的方法调用的
            var handler = (LindexiRoutedEventEventHandler) genericHandler;
            handler(genericTarget, this);
        }
    }

    public delegate void LindexiRoutedEventEventHandler(object sender,
        LindexiRoutedEventArgs e);

            xx.AddHandler(Owner.LindexiEvent, new LindexiRoutedEventEventHandler((o, args) =>
            {

            }));

    public static class LindexiExtensions
    {
        public static void AddLindexiHandler(UIElement element,
            EventHandler<LindexiRoutedEventArgs> handler)
        {
            element.AddHandler(LindexiEvent, handler);
        }

        public static void RemoveLindexiHandler(UIElement element,
            EventHandler<LindexiRoutedEventArgs> handler)
        {
            element.RemoveHandler(LindexiEvent, handler);
        }

        public static readonly RoutedEvent LindexiEvent =
            EventManager.RegisterRoutedEvent("Lindexi",
                RoutingStrategy.Bubble, typeof(EventHandler<LindexiRoutedEventArgs>),
                typeof(LindexiExtensions));

        public static void RaiseLindexiEvent(UIElement element)
        {
            element.RaiseEvent(new LindexiRoutedEventArgs(LindexiEvent, element));
        }
    }

    public class LindexiRoutedEventArgs : RoutedEventArgs
    {
        public LindexiRoutedEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source)
        {
        }

        protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        {
            // 这个方法的重写是可选的，用途是为了提升性能
            // 如无重写，底层将会调用 Delegate.DynamicInvoke 方法触发事件，这是通过反射的方法调用的
            var handler = (EventHandler<LindexiRoutedEventArgs>) genericHandler;
            handler(genericTarget, this);
        }
    }

            DependencyObject border = VisualTreeHelper.GetChild(ListView, 0);
            ScrollViewer scrollViewer = (ScrollViewer)VisualTreeHelper.GetChild(border, 0);
            scrollViewer.ScrollToBottom();

    public static class ListViewExtensions
    {
        public static void ScrollToBottom(this ListView listView)
        {
            DependencyObject border = VisualTreeHelper.GetChild(listView, 0);
            ScrollViewer scrollViewer = (ScrollViewer) VisualTreeHelper.GetChild(border, 0);
            scrollViewer.ScrollToBottom();
        }
    }

        public static BitmapSource Snap(this FrameworkElement element, double scale, int desiredHeight, int desiredWidth)
        {
            var width = (int)(element.ActualWidth);
            if (width == 0)
            {
                width = desiredWidth;
            }

            var height = (int)(element.ActualHeight);
            if (height == 0)
            {
                height = desiredHeight;
            }

            if (!element.IsLoaded)
            {
                element.Arrange(new Rect(0, 0, width, height));
                element.Measure(new Size(width, height));
            }

            var scaleWidth = (int)(width * scale);
            var scaleHeight = (int)(height * scale);

            var bitmap = new RenderTargetBitmap(scaleWidth, scaleHeight, 96.0, 96.0, PixelFormats.Pbgra32);
            var rectangle = new Rectangle
            {
                Width = scaleWidth,
                Height = scaleHeight,

                Fill = new VisualBrush(element)
                {
                    Viewbox = new Rect(0, 0, width, height),
                    ViewboxUnits = BrushMappingMode.Absolute,
                }
            };

            rectangle.Measure(new Size(scaleWidth, scaleHeight));
            rectangle.Arrange(new Rect(new Size(scaleWidth, scaleHeight)));

            bitmap.Render(rectangle);
            return bitmap;
        }

private void Foo(Page p)
{
    p.KeepAlive = true;
}

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    WindowTitle="WillBeKeptInMemory"
    KeepAlive="True">

                DependencyPropertyDescriptor.FromProperty(Border.PaddingProperty, typeof(Border)).AddValueChanged(Board,
                (s, e) =>
                {
                    Padding = Board.Padding;
                    BoardPadding = Board.Padding;
                });

public partial class Foo : FrameworkElement
{
    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
    {
        if (e.Property == FrameworkElement.WidthProperty)
        {
        }
    }
}

public class Doubi : UIElement
{
        public static readonly DependencyProperty LindexiProperty = DependencyProperty.Register(
            "Lindexi", typeof(Lindexi), typeof(Doubi), new FrameworkPropertyMetadata(default(Lindexi), FrameworkPropertyMetadataOptions.AffectsRender));

        public Lindexi Lindexi
        {
            get { return (Lindexi) GetValue(LindexiProperty); }
            set { SetValue(LindexiProperty, value); }
        }
}

    class Doubi : UIElement
    {
        public static readonly DependencyProperty F1Property = DependencyProperty.Register(
            "F1", typeof(Lindexi), typeof(Doubi), new PropertyMetadata(default(Lindexi)));

        public Lindexi F1
        {
            get { return (Lindexi) GetValue(F1Property); }
            set { SetValue(F1Property, value); }
        }

        public static readonly DependencyProperty F2Property = DependencyProperty.Register(
            "F2", typeof(double), typeof(Doubi), new PropertyMetadata(default(double)));

        public double F2
        {
            get { return (double) GetValue(F2Property); }
            set { SetValue(F2Property, value); }
        }
    }

    class Lindexi
    {

    }

        private static readonly PropertyMetadata DefaultPropertyMetadata = new PropertyMetadata(default(Lindexi));

        public static readonly DependencyProperty F1Property = DependencyProperty.Register(
            "F1", typeof(Lindexi), typeof(Doubi), DefaultPropertyMetadata);

        public Lindexi F1
        {
            get { return (Lindexi) GetValue(F1Property); }
            set { SetValue(F1Property, value); }
        }

        public static readonly DependencyProperty F2Property = DependencyProperty.Register(
            "F2", typeof(double), typeof(Doubi), DefaultPropertyMetadata);

        public double F2
        {
            get { return (double) GetValue(F2Property); }
            set { SetValue(F2Property, value); }
        }

            InkPointListView.SelectedIndex = selectedIndex;

            if (selectedIndex >= 0 && selectedIndex < InkPointListView.Items.Count)
            {
                InkPointListView.ScrollIntoView(InkPointListView.Items[selectedIndex]);
            }

        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
            "Text", typeof(string), typeof(TextControl));

        public string Text
        {
            get { return "lindexi is doubi"; }
            set { SetValue(TextProperty, value); }
        }

    /// <summary>
    /// Use as first line in ad hoc tests (needed by XNA specifically)
    /// </summary>
    public static void SetEntryAssembly()
    {
        SetEntryAssembly(Assembly.GetCallingAssembly());
    }

    /// <summary>
    /// Allows setting the Entry Assembly when needed. 
    /// Use AssemblyUtilities.SetEntryAssembly() as first line in XNA ad hoc tests
    /// </summary>
    /// <param name="assembly">Assembly to set as entry assembly</param>
    public static void SetEntryAssembly(Assembly assembly)
    {
        AppDomainManager manager = new AppDomainManager();
        FieldInfo entryAssemblyField = manager.GetType().GetField("m_entryAssembly", BindingFlags.Instance | BindingFlags.NonPublic);
        entryAssemblyField.SetValue(manager, assembly);

        AppDomain domain = AppDomain.CurrentDomain;
        FieldInfo domainManagerField = domain.GetType().GetField("_domainManager", BindingFlags.Instance | BindingFlags.NonPublic);
        domainManagerField.SetValue(domain, manager);
    }

ButtonAutomationPeer peer = new ButtonAutomationPeer(someButton);
IInvokeProvider invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
invokeProv.Invoke();

        protected override Size MeasureOverride(Size availableSize)
        {
            // availableSize = {300, 250}
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            return new Size(10, 10);
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            // finalSize = {10,10}
            return base.ArrangeOverride(finalSize);
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            return new Size(5000, 10);
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            // finalSize = {5000,10}
            return base.ArrangeOverride(finalSize);
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            // {300,250}
            return new Size(10, 10);
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            // {10,250}
            return base.ArrangeOverride(finalSize);
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            // {300,250}
            return new Size(1000, 2000);
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            // {1000,2000}
            return base.ArrangeOverride(finalSize);
        }

    <StackPanel Width="300" Height="250">
    </StackPanel>

        protected override Size MeasureOverride(Size availableSize)
        {
            // {300,∞}
            return new Size(10, 10);
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            // {300,10}
            return base.ArrangeOverride(finalSize);
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            // {300,∞}
            return new Size(600, 1000);
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            // {600,1000}
            return base.ArrangeOverride(finalSize);
        }

    private void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        TextBox.SelectionChanged += (sender, e) => MoveCustomCaret((TextBox)sender);
        TextBox.LostFocus += (sender, e) => CaretBorder.Visibility = Visibility.Collapsed;
        TextBox.GotFocus += (sender, e) => CaretBorder.Visibility = Visibility.Visible;
    }

    private void MoveCustomCaret(TextBox textBox)
    {
        var caretLocation = textBox.GetRectFromCharacterIndex(textBox.CaretIndex).Location;

        if (!double.IsInfinity(caretLocation.X))
        {
            Canvas.SetLeft(CaretBorder, caretLocation.X);
        }

        if (!double.IsInfinity(caretLocation.Y))
        {
            Canvas.SetTop(CaretBorder, caretLocation.Y);
        }
    }

        /// <summary>
        ///   Sends the specified key.
        /// </summary>
        public static void SendKey(Key key)
        {
            SendKeyDown(key);
            SendKeyUp(key);
        }

        /// <summary>
        ///   Sends the specified key.
        /// </summary>
        /// Form: https://stackoverflow.com/a/21074234/6116637
        /// <param name="key">The key.</param>
        public static void SendKeyDown(Key key)
        {
            if (Keyboard.PrimaryDevice != null)
            {
                if (Keyboard.PrimaryDevice.ActiveSource != null)
                {
                    var e = new KeyEventArgs(Keyboard.PrimaryDevice, Keyboard.PrimaryDevice.ActiveSource, 0, key)
                    {
                        RoutedEvent = Keyboard.KeyDownEvent
                    };
                    InputManager.Current.ProcessInput(e);
                }
            }
        }

        /// <summary>
        ///   Sends the specified key.
        /// </summary>
        /// Form: https://stackoverflow.com/a/21074234/6116637
        public static void SendKeyUp(Key key)
        {
            if (Keyboard.PrimaryDevice != null)
            {
                if (Keyboard.PrimaryDevice.ActiveSource != null)
                {
                    var e = new KeyEventArgs(Keyboard.PrimaryDevice, Keyboard.PrimaryDevice.ActiveSource, 0, key)
                    {
                        RoutedEvent = Keyboard.KeyUpEvent
                    };
                    InputManager.Current.ProcessInput(e);
                }
            }
        }

            var mouseWheelEventArgs =
                new MouseWheelEventArgs(InputManager.Current.PrimaryMouseDevice, Environment.TickCount, -120);
            mouseWheelEventArgs.RoutedEvent = UIElement.MouseWheelEvent;
            board.RaiseEvent(mouseWheelEventArgs);

    public Win32Exception()
      : this(Marshal.GetLastWin32Error())
    {
    }

            HandleRef h = new HandleRef(null, new IntPtr(5));

            var dc = IntGetDC(h);
            if (dc == IntPtr.Zero)
            {
                var lastWin32Error = Marshal.GetLastWin32Error();

                var e = new Win32Exception();

                Console.WriteLine(e.NativeErrorCode == lastWin32Error);
            }

        [DllImport("user32.dll", SetLastError = true, ExactSpelling = true, EntryPoint = "GetDC", CharSet = CharSet.Auto)]
        private static extern IntPtr IntGetDC(HandleRef hWnd);

        /// <summary>
        /// 监听窗口消息以处理横向滚轮/触控板横向移动的消息。
        /// </summary>
        private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            const int WM_MOUSEHWHEEL = 0x020E;
            switch (msg)
            {
                case WM_MOUSEHWHEEL:
                    int tilt = (short)HIWORD(wParam);
                    OnMouseTilt(tilt);
                    return (IntPtr)1;
            }

            return IntPtr.Zero;
        }

        /// <summary>
        /// 取指针所在高位数值。
        /// </summary>
        private static int HIWORD(IntPtr ptr)
        {
            var val32 = ptr.ToInt32();
            return ((val32 >> 16) & 0xFFFF);
        }

        /// <summary>
        /// 鼠标横向滚轮触发时，横向滚动。
        /// </summary>
        /// <param name="tilt">横向滚动量，类似于竖向滚动里的 delta。</param>
        private void OnMouseTilt(int tilt)
        {
        }

            var touchAction = e.GetTouchPoint(this).Action;
            if (touchAction == TouchAction.Up)
            {
                // 由于抬起的原因，那就不能算进离开窗口
                return;
            }

 _textArea.CommandBindings.Add(new CommandBinding(EditingCommands.Backspace, OnBackspace));
 _textArea.InputBindings.Add(new KeyBinding(EditingCommands.Backspace, Key.Back, ModifierKeys.None));

System.InvalidOperationException:“无法在对象“System.Windows.Media.DrawingGroup”上设置属性，因为它处于只读状态。”

DrawingGroup drawingGroup = Draw();
drawingGroup.Freeze();
drawingGroup.Transform = translateTransform;

    private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        await Task.Delay(2000);
        Hide();
        await Task.Delay(2000);
        WindowState = WindowState.Maximized;
        await Task.Delay(1000);
        Show();
    }

    private void MenuItem_OnClick(object sender, RoutedEventArgs e)
    {
        var menuItem = (MenuItem) sender;

        DependencyObject t = menuItem;
        while (t != null)
        {
            t = LogicalTreeHelper.GetParent(t);

            if (t is ContextMenu)
            {
                break;
            }
        }

        var c = t as ContextMenu;
        var placementTarget = c?.PlacementTarget as Grid;
    }